From b6a26390556fe14c3fc9634b291baabeba7ed517 Mon Sep 17 00:00:00 2001 From: Czarek Nakamoto Date: Tue, 10 Mar 2026 08:49:35 +0100 Subject: monero updates --- .gitignore | 2 + build_single.sh | 48 +- generate_checksum.sh | 12 +- impls/monero.dart/lib/src/checksum_monero.dart | 6 +- impls/monero.dart/lib/src/checksum_wownero.dart | 2 +- impls/monero.dart/lib/src/checksum_zano.dart | 2 +- impls/monero.ts/checksum_monero.ts | 6 +- impls/monero.ts/checksum_wownero.ts | 2 +- impls/monero.ts/checksum_zano.ts | 2 +- monero_libwallet2_api_c/CMakeLists.txt | 115 +- .../monero_libwallet2_api_c.exp | 40 + .../src/main/cpp/monero_checksum.c | 5 + .../src/main/cpp/monero_checksum.h | 22 +- .../src/main/cpp/monero_wallet2_api_c.cpp | 2676 ++++++++++++++++++++ .../src/main/cpp/monero_wallet2_api_c.h | 1049 ++++++++ .../src/main/cpp/wallet2_api_c.cpp | 2630 ------------------- .../src/main/cpp/wallet2_api_c.h | 1042 -------- tests/c/Makefile | 58 + tests/c/src/main.c | 12 + tests/c/src/utils.c | 65 + tests/c/src/utils.h | 8 + tests/c/tests/all.h | 7 + tests/c/tests/monero_test_creation.c | 55 + tests/c/tests/monero_test_restore.c | 255 ++ .../src/main/cpp/wallet2_api_c.cpp | 2515 ------------------ .../src/main/cpp/wallet2_api_c.h | 1019 -------- .../src/main/cpp/wownero_checksum.c | 5 + .../src/main/cpp/wownero_wallet2_api_c.cpp | 2513 ++++++++++++++++++ .../src/main/cpp/wownero_wallet2_api_c.h | 1019 ++++++++ .../src/main/cpp/wallet2_api_c.cpp | 322 --- zano_libwallet2_api_c/src/main/cpp/wallet2_api_c.h | 67 - zano_libwallet2_api_c/src/main/cpp/zano_checksum.c | 5 + .../src/main/cpp/zano_wallet2_api_c.cpp | 322 +++ .../src/main/cpp/zano_wallet2_api_c.h | 67 + 34 files changed, 8247 insertions(+), 7728 deletions(-) create mode 100644 monero_libwallet2_api_c/src/main/cpp/monero_checksum.c create mode 100644 monero_libwallet2_api_c/src/main/cpp/monero_wallet2_api_c.cpp create mode 100644 monero_libwallet2_api_c/src/main/cpp/monero_wallet2_api_c.h delete mode 100644 monero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp delete mode 100644 monero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h create mode 100644 tests/c/Makefile create mode 100644 tests/c/src/main.c create mode 100644 tests/c/src/utils.c create mode 100644 tests/c/src/utils.h create mode 100644 tests/c/tests/all.h create mode 100644 tests/c/tests/monero_test_creation.c create mode 100644 tests/c/tests/monero_test_restore.c delete mode 100644 wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp delete mode 100644 wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h create mode 100644 wownero_libwallet2_api_c/src/main/cpp/wownero_checksum.c create mode 100644 wownero_libwallet2_api_c/src/main/cpp/wownero_wallet2_api_c.cpp create mode 100644 wownero_libwallet2_api_c/src/main/cpp/wownero_wallet2_api_c.h delete mode 100644 zano_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp delete mode 100644 zano_libwallet2_api_c/src/main/cpp/wallet2_api_c.h create mode 100644 zano_libwallet2_api_c/src/main/cpp/zano_checksum.c create mode 100644 zano_libwallet2_api_c/src/main/cpp/zano_wallet2_api_c.cpp create mode 100644 zano_libwallet2_api_c/src/main/cpp/zano_wallet2_api_c.h diff --git a/.gitignore b/.gitignore index 706bca7..12bf358 100644 --- a/.gitignore +++ b/.gitignore @@ -11,3 +11,5 @@ contrib/depends/simplybs ./monero ./wownero ./zano +*.o +test_wallet2_api_c diff --git a/build_single.sh b/build_single.sh index 8be1e0b..760b4a5 100755 --- a/build_single.sh +++ b/build_single.sh @@ -60,7 +60,7 @@ pushd contrib/depends then sbs_BOOST_VERSION=1_83_0 fi - env PATH="$PATH" make "$NPROC" HOST="$HOST_ABI" BOOST_VERSION="${sbs_BOOST_VERSION}" + echo env PATH="$PATH" make "$NPROC" HOST="$HOST_ABI" BOOST_VERSION="${sbs_BOOST_VERSION}" popd # source contrib/depends/_native/_source_me source contrib/depends/$HOST_ABI/_source_me @@ -68,34 +68,24 @@ export PATH="$(pwd)/contrib/depends/_native/bin/:$(pwd)/contrib/depends/$HOST_AB buildType=Release -pushd ${repo}_libwallet2_api_c - rm -rf build/${HOST_ABI} || true - mkdir -p build/${HOST_ABI} - if [[ "$repo" == "zano" ]]; - then - EXTRA_CMAKE_FLAGS="-DCAKEWALLET=ON" - fi - pushd build/${HOST_ABI} - cmake --trace-expand -DCMAKE_TOOLCHAIN_FILE=$PWD/../../../contrib/depends/${HOST_ABI}/share/toolchain.cmake $EXTRA_CMAKE_FLAGS -DUSE_DEVICE_TREZOR=OFF -DMONERO_FLAVOR=$repo -DCMAKE_BUILD_TYPE=Debug -DHOST_ABI=${HOST_ABI} ../.. - make $NPROC +for OUTPUT_MODE in SHARED; +do + pushd ${repo}_libwallet2_api_c + rm -rf build/${HOST_ABI}_${OUTPUT_MODE} || true + mkdir -p build/${HOST_ABI}_${OUTPUT_MODE} + if [[ "$repo" == "zano" ]]; + then + EXTRA_CMAKE_FLAGS="-DCAKEWALLET=ON" + fi + pushd build/${HOST_ABI}_${OUTPUT_MODE} + cmake -DCMAKE_TOOLCHAIN_FILE=$PWD/../../../contrib/depends/${HOST_ABI}/share/toolchain.cmake $EXTRA_CMAKE_FLAGS -DUSE_DEVICE_TREZOR=OFF -DMONERO_FLAVOR=$repo -DCMAKE_BUILD_TYPE=Debug -DHOST_ABI=${HOST_ABI} -DOUTPUT_MODE=${OUTPUT_MODE} ../.. + make $NPROC + popd popd -popd +done -mkdir -p release/$repo 2>/dev/null || true -pushd release/$repo - APPENDIX="" - if [[ "${HOST_ABI}" == "x86_64-w64-mingw32" || "${HOST_ABI}" == "i686-w64-mingw32" ]]; - then - echo "TODO: check if it's still needed" - APPENDIX="${APPENDIX}dll" - # cp ../../$repo/build/${HOST_ABI}/external/polyseed/libpolyseed.${APPENDIX} ${HOST_ABI}_libpolyseed.${APPENDIX} - # rm ${HOST_ABI}_libpolyseed.${APPENDIX}.xz || true - # xz -e ${HOST_ABI}_libpolyseed.${APPENDIX} - elif [[ "${HOST_ABI}" == "x86_64-apple-darwin11" || "${HOST_ABI}" == "aarch64-apple-darwin11" || "${HOST_ABI}" == "host-apple-darwin" || "${HOST_ABI}" == "x86_64-host-apple-darwin" || "${HOST_ABI}" == "aarch64-apple-darwin" || "${HOST_ABI}" == "x86_64-apple-darwin" || "${HOST_ABI}" == "host-apple-ios" || "${HOST_ABI}" == "aarch64-apple-ios" || "${HOST_ABI}" == "aarch64-apple-ios-simulator" ]]; - then - APPENDIX="${APPENDIX}dylib" - else - APPENDIX="${APPENDIX}so" - fi - mv ../../${repo}_libwallet2_api_c/build/${HOST_ABI}/libwallet2_api_c.${APPENDIX} ${HOST_ABI}_libwallet2_api_c.${APPENDIX} +mkdir -p release/$(git describe --tags)/${HOST_ABI} 2>/dev/null || true +pushd release/$(git describe --tags)/${HOST_ABI} + pwd + mv ../../../${repo}_libwallet2_api_c/build/${HOST_ABI}_*/lib*_wallet2_api_c.* . popd diff --git a/generate_checksum.sh b/generate_checksum.sh index ea59961..3793a54 100755 --- a/generate_checksum.sh +++ b/generate_checksum.sh @@ -10,17 +10,16 @@ for coin in monero wownero zano; do submodule_hash=$(git ls-tree HEAD ${coin} | xargs | awk '{ print $3 }') COIN=$(echo "$coin" | tr a-z A-Z) - COIN_wallet2_api_c_h_sha256=$(sha256sum ${coin}_libwallet2_api_c/src/main/cpp/wallet2_api_c.h | xargs | awk '{ print $1 }') - COIN_wallet2_api_c_cpp_sha256=$(sha256sum ${coin}_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp | xargs | awk '{ print $1 }')-${submodule_hash} + COIN_wallet2_api_c_h_sha256=$(sha256sum ${coin}_libwallet2_api_c/src/main/cpp/${coin}_wallet2_api_c.h | xargs | awk '{ print $1 }') + COIN_wallet2_api_c_cpp_sha256=$(sha256sum ${coin}_libwallet2_api_c/src/main/cpp/${coin}_wallet2_api_c.cpp | xargs | awk '{ print $1 }')-${submodule_hash} COIN_wallet2_api_c_exp_sha256=$(sha256sum ${coin}_libwallet2_api_c/${coin}_libwallet2_api_c.exp | xargs | awk '{ print $1 }') - cat > ${coin}_libwallet2_api_c/src/main/cpp/${coin}_checksum.h << EOF -#ifndef MONEROC_CHECKSUMS -#define MONEROC_CHECKSUMS + cat > ${coin}_libwallet2_api_c/src/main/cpp/${coin}_checksum.c << EOF +#include "${coin}_checksum.h" + const char * ${COIN}_wallet2_api_c_h_sha256 = "${COIN_wallet2_api_c_h_sha256}"; const char * ${COIN}_wallet2_api_c_cpp_sha256 = "${COIN_wallet2_api_c_cpp_sha256}"; const char * ${COIN}_wallet2_api_c_exp_sha256 = "${COIN_wallet2_api_c_exp_sha256}"; -#endif EOF cat > impls/monero.dart/lib/src/checksum_${coin}.dart << EOF // ignore_for_file: constant_identifier_names @@ -36,4 +35,3 @@ export const ${coin}Checksum = { } EOF done - diff --git a/impls/monero.dart/lib/src/checksum_monero.dart b/impls/monero.dart/lib/src/checksum_monero.dart index 27cbe36..eae7d97 100644 --- a/impls/monero.dart/lib/src/checksum_monero.dart +++ b/impls/monero.dart/lib/src/checksum_monero.dart @@ -1,4 +1,4 @@ // ignore_for_file: constant_identifier_names -const String wallet2_api_c_h_sha256 = "3515e4c9e537ca3efa664f0b364a3aeb106ff64337f542a262ce104c00b31235"; -const String wallet2_api_c_cpp_sha256 = "ca44a8d4a201ba6dc0a25c857e95d07bc8d514039b38cd5b3826100e8943cbcc-dbcc7d212c094bd1a45f7291dbb99a4b4627a96d"; -const String wallet2_api_c_exp_sha256 = "0561e14606106e6b0ec49fb2aefe743ff500f7c3de07557f7041e06aef9509ce"; +const String wallet2_api_c_h_sha256 = "e7117f437964c7bd7dc90ced932432b4571113bd1e981238c689e297ec02a9e5"; +const String wallet2_api_c_cpp_sha256 = "8329ea5c29578a48cf8a15ebe4de693bc412b7b6fdc053290f8c4719ffad54d0-dbcc7d212c094bd1a45f7291dbb99a4b4627a96d"; +const String wallet2_api_c_exp_sha256 = "135c0e3c7088e43cfbbff00fc814addb8929a1116324a618c7276bd789b78563"; diff --git a/impls/monero.dart/lib/src/checksum_wownero.dart b/impls/monero.dart/lib/src/checksum_wownero.dart index a1d39ee..a6899c3 100644 --- a/impls/monero.dart/lib/src/checksum_wownero.dart +++ b/impls/monero.dart/lib/src/checksum_wownero.dart @@ -1,4 +1,4 @@ // ignore_for_file: constant_identifier_names const String wallet2_api_c_h_sha256 = "f99009d1ca1d1c783cc9aa0fb63f680d48753b88124fb5de2079c57b7e34c827"; -const String wallet2_api_c_cpp_sha256 = "70b39a0bef660cb9ba0397117eb1590e18461ace89ab18141690658a2a537d5d-cfd2a696245be112a01936d1f2f41b6eb7558376"; +const String wallet2_api_c_cpp_sha256 = "a4539145783e7909afe087ce6ba5343b878e102bc493ab4283e653cd2b2c118e-cfd2a696245be112a01936d1f2f41b6eb7558376"; const String wallet2_api_c_exp_sha256 = "5f53ea8bbe66a5e5aa6cbc4ca00695900e08589cfd32062e88965a24252d05ba"; diff --git a/impls/monero.dart/lib/src/checksum_zano.dart b/impls/monero.dart/lib/src/checksum_zano.dart index cff01f2..a37c254 100644 --- a/impls/monero.dart/lib/src/checksum_zano.dart +++ b/impls/monero.dart/lib/src/checksum_zano.dart @@ -1,4 +1,4 @@ // ignore_for_file: constant_identifier_names const String wallet2_api_c_h_sha256 = "8acaa95513b85a984c08e05cc3f2ac7530bb8f32946eeeb45357bd846aef33dd"; -const String wallet2_api_c_cpp_sha256 = "4efacd3812d53dd268b6869cc0a9560e7320574d96e09136cf067f796edfeba6-b372a99c7ada82caac53b677d9aaa7c0902e3b0b"; +const String wallet2_api_c_cpp_sha256 = "326c2b134918db2f139075e8051e2531725689e5a672496792684d5fd35dd156-b372a99c7ada82caac53b677d9aaa7c0902e3b0b"; const String wallet2_api_c_exp_sha256 = "66f3ff655bbfd11ad28c318ab707090b5a93276f436b06f7b1c0f329dba3c9c2"; diff --git a/impls/monero.ts/checksum_monero.ts b/impls/monero.ts/checksum_monero.ts index 81eba33..97f87d9 100644 --- a/impls/monero.ts/checksum_monero.ts +++ b/impls/monero.ts/checksum_monero.ts @@ -1,5 +1,5 @@ export const moneroChecksum = { - wallet2_api_c_h_sha256: "3515e4c9e537ca3efa664f0b364a3aeb106ff64337f542a262ce104c00b31235", - wallet2_api_c_cpp_sha256: "ca44a8d4a201ba6dc0a25c857e95d07bc8d514039b38cd5b3826100e8943cbcc-dbcc7d212c094bd1a45f7291dbb99a4b4627a96d", - wallet2_api_c_exp_sha256: "0561e14606106e6b0ec49fb2aefe743ff500f7c3de07557f7041e06aef9509ce", + wallet2_api_c_h_sha256: "e7117f437964c7bd7dc90ced932432b4571113bd1e981238c689e297ec02a9e5", + wallet2_api_c_cpp_sha256: "8329ea5c29578a48cf8a15ebe4de693bc412b7b6fdc053290f8c4719ffad54d0-dbcc7d212c094bd1a45f7291dbb99a4b4627a96d", + wallet2_api_c_exp_sha256: "135c0e3c7088e43cfbbff00fc814addb8929a1116324a618c7276bd789b78563", } diff --git a/impls/monero.ts/checksum_wownero.ts b/impls/monero.ts/checksum_wownero.ts index c7b7e75..8454571 100644 --- a/impls/monero.ts/checksum_wownero.ts +++ b/impls/monero.ts/checksum_wownero.ts @@ -1,5 +1,5 @@ export const wowneroChecksum = { wallet2_api_c_h_sha256: "f99009d1ca1d1c783cc9aa0fb63f680d48753b88124fb5de2079c57b7e34c827", - wallet2_api_c_cpp_sha256: "70b39a0bef660cb9ba0397117eb1590e18461ace89ab18141690658a2a537d5d-cfd2a696245be112a01936d1f2f41b6eb7558376", + wallet2_api_c_cpp_sha256: "a4539145783e7909afe087ce6ba5343b878e102bc493ab4283e653cd2b2c118e-cfd2a696245be112a01936d1f2f41b6eb7558376", wallet2_api_c_exp_sha256: "5f53ea8bbe66a5e5aa6cbc4ca00695900e08589cfd32062e88965a24252d05ba", } diff --git a/impls/monero.ts/checksum_zano.ts b/impls/monero.ts/checksum_zano.ts index 6080ed1..e0fdbaa 100644 --- a/impls/monero.ts/checksum_zano.ts +++ b/impls/monero.ts/checksum_zano.ts @@ -1,5 +1,5 @@ export const zanoChecksum = { wallet2_api_c_h_sha256: "8acaa95513b85a984c08e05cc3f2ac7530bb8f32946eeeb45357bd846aef33dd", - wallet2_api_c_cpp_sha256: "4efacd3812d53dd268b6869cc0a9560e7320574d96e09136cf067f796edfeba6-b372a99c7ada82caac53b677d9aaa7c0902e3b0b", + wallet2_api_c_cpp_sha256: "326c2b134918db2f139075e8051e2531725689e5a672496792684d5fd35dd156-b372a99c7ada82caac53b677d9aaa7c0902e3b0b", wallet2_api_c_exp_sha256: "66f3ff655bbfd11ad28c318ab707090b5a93276f436b06f7b1c0f329dba3c9c2", } diff --git a/monero_libwallet2_api_c/CMakeLists.txt b/monero_libwallet2_api_c/CMakeLists.txt index f11c2bc..7952dcd 100644 --- a/monero_libwallet2_api_c/CMakeLists.txt +++ b/monero_libwallet2_api_c/CMakeLists.txt @@ -1,13 +1,11 @@ cmake_minimum_required(VERSION 3.5) -project(wallet2_api_c) -message(STATUS ABI_INFO = ${HOST_ABI}) +project(${MONERO_FLAVOR}_wallet2_api_c) +message(STATUS HOST_ABI = ${HOST_ABI}) set(MD_LIBRARY "") set(CMAKE_CXX_STANDARD 11) set(CMAKE_POSITION_INDEPENDENT_CODE ON) -# set(CMAKE_INTERPROCEDURAL_OPTIMIZATION FALSE) -# set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fno-lto") if(${HOST_ABI} STREQUAL "x86_64-w64-mingw32") set(CMAKE_SYSTEM_NAME Windows) @@ -21,92 +19,60 @@ elseif(${HOST_ABI} STREQUAL "i686-w64-mingw32") set(TARGET "i686-w64-mingw32") set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -lssp") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -lssp") -elseif(${HOST_ABI} STREQUAL "host-apple-ios" OR - ${HOST_ABI} STREQUAL "aarch64-apple-ios") +elseif(${HOST_ABI} MATCHES "-apple-ios") set(CMAKE_SYSTEM_NAME iOS) -elseif(${HOST_ABI} STREQUAL "host-apple-darwin" OR - ${HOST_ABI} STREQUAL "x86_64-host-apple-darwin" OR - ${HOST_ABI} STREQUAL "aarch64-host-apple-darwin") +elseif(${HOST_ABI} MATCHES "-apple-darwin") set(CMAKE_SYSTEM_NAME Darwin) endif() -if (${HOST_ABI} STREQUAL "host-apple-darwin" OR - ${HOST_ABI} STREQUAL "x86_64-host-apple-darwin" OR - ${HOST_ABI} STREQUAL "aarch64-host-apple-darwin") +if (${HOST_ABI} MATCHES "-apple-darwin") EXECUTE_PROCESS( COMMAND uname -m COMMAND tr -d '\n' OUTPUT_VARIABLE ARCHITECTURE ) if (NOT ${ARCHITECTURE} STREQUAL arm64) set(CMAKE_OSX_ARCHITECTURES x86_64) endif() endif() -if(${HOST_ABI} STREQUAL "x86_64-linux-android" OR - ${HOST_ABI} STREQUAL "i686-linux-android" OR - ${HOST_ABI} STREQUAL "aarch64-linux-android" OR - ${HOST_ABI} STREQUAL "armv7a-linux-androideabi") +if(${HOST_ABI} MATCHES "-linux-android") add_link_options(-stdlib=libc++ -static-libstdc++) set(EXTRA_LIBS_ANDROID log) endif() -add_library( wallet2_api_c - SHARED + +add_library( ${MONERO_FLAVOR}_wallet2_api_c + ${OUTPUT_MODE} src/main/cpp/helpers.cpp - src/main/cpp/wallet2_api_c.cpp ) + src/main/cpp/${MONERO_FLAVOR}_wallet2_api_c.cpp + src/main/cpp/${MONERO_FLAVOR}_checksum.c) -if(${HOST_ABI} STREQUAL "x86_64-linux-android" OR - ${HOST_ABI} STREQUAL "i686-linux-android" OR - ${HOST_ABI} STREQUAL "aarch64-linux-android" OR - ${HOST_ABI} STREQUAL "armv7a-linux-androideabi") - set_target_properties(wallet2_api_c PROPERTIES LINK_FLAGS "-Wl,-z,noexecstack") +if(${HOST_ABI} MATCHES "-linux-android") + set_target_properties(${MONERO_FLAVOR}_wallet2_api_c PROPERTIES LINK_FLAGS "-Wl,-z,noexecstack") endif() -if(${HOST_ABI} STREQUAL "x86_64-linux-gnu" OR - ${HOST_ABI} STREQUAL "i686-linux-gnu" OR - ${HOST_ABI} STREQUAL "aarch64-linux-gnu" OR - ${HOST_ABI} STREQUAL "armv7a-linux-gnu") - set_target_properties(wallet2_api_c PROPERTIES LINK_FLAGS "-Wl,-z,noexecstack") +if(${HOST_ABI} MATCHES "-linux-gnu") + set_target_properties(${MONERO_FLAVOR}_wallet2_api_c PROPERTIES LINK_FLAGS "-Wl,-z,noexecstack") endif() - set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden") set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fvisibility=hidden") - - set(MONERO_DIR ${CMAKE_SOURCE_DIR}/../${MONERO_FLAVOR}) set(EXTERNAL_LIBS_DIR ${CMAKE_SOURCE_DIR}/../contrib/depends/${HOST_ABI}) -if (${HOST_ABI} STREQUAL "x86_64-apple-darwin11" OR ${HOST_ABI} STREQUAL "aarch64-apple-darwin11") - set(EXTRA_LIBS_APPLE "-framework IOKit" "-framework CoreFoundation" "-framework Cocoa" hidapi) -# set_target_properties(wallet2_api_c PROPERTIES LINK_FLAGS "-Wl,-F/Library/Frameworks") -elseif(${HOST_ABI} STREQUAL "host-apple-darwin" OR - ${HOST_ABI} STREQUAL "x86_64-host-apple-darwin" OR - ${HOST_ABI} STREQUAL "aarch64-host-apple-darwin") - set(EXTRA_LIBS_APPLE "-framework IOKit" "-framework CoreFoundation" "-framework Cocoa" apple_nghttp2) -elseif(${HOST_ABI} STREQUAL "host-apple-ios" OR ${HOST_ABI} STREQUAL "aarch64-apple-ios" OR ${HOST_ABI} STREQUAL "arm64-apple-ios" OR ${HOST_ABI} STREQUAL "arm64-apple-ios-simulator" OR ${HOST_ABI} STREQUAL "x86_64-apple-ios-simulator") - set(EXTRA_LIBS_APPLE "-framework IOKit" "-framework CoreFoundation" iconv ) -endif() - if(${HOST_ABI} STREQUAL "x86_64-w64-mingw32" OR ${HOST_ABI} STREQUAL "i686-w64-mingw32") - target_link_options(wallet2_api_c PRIVATE -static-libgcc -static-libstdc++) -endif() - -if(${HOST_ABI} STREQUAL "x86_64-apple-darwin11" OR ${HOST_ABI} STREQUAL "aarch64-apple-darwin11" OR ${HOST_ABI} STREQUAL "host-apple-darwin" OR ${HOST_ABI} STREQUAL "x86_64-host-apple-darwin" OR ${HOST_ABI} STREQUAL "aarch64-host-apple-darwin" OR ${HOST_ABI} STREQUAL "host-apple-ios" OR ${HOST_ABI} STREQUAL "aarch64-apple-ios" OR ${HOST_ABI} STREQUAL "arm64-apple-iossimulator" OR ${HOST_ABI} STREQUAL "x86_64-apple-iossimulator") - set_target_properties(wallet2_api_c PROPERTIES SUFFIX ".dylib") - - set_target_properties(wallet2_api_c PROPERTIES NO_SONAME 1) + target_link_options(${MONERO_FLAVOR}_wallet2_api_c PRIVATE -static-libgcc -static-libstdc++) endif() if (${MONERO_FLAVOR} STREQUAL "monero") - target_compile_definitions(wallet2_api_c PRIVATE FLAVOR_MONERO) + target_compile_definitions(${MONERO_FLAVOR}_wallet2_api_c PRIVATE FLAVOR_MONERO) set(BCUR_ENABLED bc-ur) elseif(${MONERO_FLAVOR} STREQUAL "wownero") - target_compile_definitions(wallet2_api_c PRIVATE FLAVOR_WOWNERO) + target_compile_definitions(${MONERO_FLAVOR}_wallet2_api_c PRIVATE FLAVOR_WOWNERO) elseif(${MONERO_FLAVOR} STREQUAL "zano") - target_compile_definitions(wallet2_api_c PRIVATE FLAVOR_ZANO) + target_compile_definitions(${MONERO_FLAVOR}_wallet2_api_c PRIVATE FLAVOR_ZANO) endif() -if(NOT ${HOST_ABI} STREQUAL "x86_64-apple-darwin11" AND NOT ${HOST_ABI} STREQUAL "aarch64-apple-darwin11" AND NOT ${HOST_ABI} STREQUAL "aarch64-apple-darwin" AND NOT ${HOST_ABI} STREQUAL "x86_64-apple-darwin" AND NOT ${HOST_ABI} STREQUAL "host-apple-darwin" AND NOT ${HOST_ABI} STREQUAL "x86_64-host-apple-darwin" AND NOT ${HOST_ABI} STREQUAL "aarch64-host-apple-darwin" AND NOT ${HOST_ABI} STREQUAL "host-apple-ios" AND NOT ${HOST_ABI} STREQUAL "aarch64-apple-ios" AND NOT ${HOST_ABI} STREQUAL "aarch64-apple-ios-simulator" AND NOT ${HOST_ABI} STREQUAL "x86_64-apple-ios-simulator") - set_target_properties(wallet2_api_c PROPERTIES LINK_FLAGS "-Wl,--exclude-libs,ALL") +if(NOT HOST_ABI MATCHES "-apple-") + set_target_properties(${MONERO_FLAVOR}_wallet2_api_c PROPERTIES LINK_FLAGS "-Wl,--exclude-libs,ALL") endif() if (${MONERO_FLAVOR} STREQUAL "zano") @@ -116,26 +82,19 @@ if (${MONERO_FLAVOR} STREQUAL "zano") endif() add_subdirectory("${CMAKE_SOURCE_DIR}/../${MONERO_FLAVOR}" ${CMAKE_BINARY_DIR}/${MONERO_FLAVOR}_build EXCLUDE_FROM_ALL) -if(${HOST_ABI} STREQUAL "x86_64-apple-darwin11" OR ${HOST_ABI} STREQUAL "aarch64-apple-darwin11" OR ${HOST_ABI} STREQUAL "x86_64-apple-darwin" OR ${HOST_ABI} STREQUAL "aarch64-apple-darwin" OR ${HOST_ABI} STREQUAL "host-apple-darwin" OR ${HOST_ABI} STREQUAL "x86_64-host-apple-darwin" OR ${HOST_ABI} STREQUAL "aarch64-host-apple-darwin" OR ${HOST_ABI} STREQUAL "host-apple-ios" OR ${HOST_ABI} STREQUAL "aarch64-apple-ios" OR ${HOST_ABI} STREQUAL "aarch64-apple-iossimulator" OR ${HOST_ABI} STREQUAL "x86_64-apple-ios-simulator") - if (${MONERO_FLAVOR} STREQUAL "monero") - set(EXPORTED_SYMBOLS_FILE ${CMAKE_CURRENT_SOURCE_DIR}/monero_libwallet2_api_c.exp) - elseif(${MONERO_FLAVOR} STREQUAL "wownero") - set(EXPORTED_SYMBOLS_FILE ${CMAKE_CURRENT_SOURCE_DIR}/wownero_libwallet2_api_c.exp) - elseif(${MONERO_FLAVOR} STREQUAL "zano") - set(EXPORTED_SYMBOLS_FILE ${CMAKE_CURRENT_SOURCE_DIR}/zano_libwallet2_api_c.exp) - endif() + +if(HOST_ABI MATCHES "-apple-") + set(EXPORTED_SYMBOLS_FILE ${CMAKE_CURRENT_SOURCE_DIR}/${MONERO_FLAVOR}_libwallet2_api_c.exp) set(CMAKE_SHARED_LINKER_FLAGS "${CMAKE_SHARED_LINKER_FLAGS} -exported_symbols_list ${EXPORTED_SYMBOLS_FILE}") set_target_properties(${TARGET} PROPERTIES LINK_DEPENDS ${EXPORTED_SYMBOLS_FILE}) endif() -if (${MONERO_FLAVOR} STREQUAL "monero") - set(WALLET_TARGETS wallet_api ${wallet_api_LIB_DEPENDS}) # wallet_api_LIB_DEPENDS -elseif(${MONERO_FLAVOR} STREQUAL "wownero") - set(WALLET_TARGETS wallet_api ${wallet_api_LIB_DEPENDS}) # wallet_api_LIB_DEPENDS +if (${MONERO_FLAVOR} STREQUAL "monero" OR ${MONERO_FLAVOR} STREQUAL "wownero") + set(WALLET_TARGETS wallet_api ${wallet_api_LIB_DEPENDS}) elseif(${MONERO_FLAVOR} STREQUAL "zano") set(THREADS_PREFER_PTHREAD_FLAG ON) - + set(CMAKE_THREAD_LIBS_INIT "-lpthread") set(CMAKE_HAVE_THREADS_LIBRARY 1) set(CMAKE_USE_PTHREADS_INIT 1) @@ -160,22 +119,10 @@ if(${MONERO_FLAVOR} STREQUAL "wownero") set(EXTRA_LIBS_WOWNEROSEED wownero-seed) endif() -#get_cmake_property(_variableNames VARIABLES) -#list (SORT _variableNames) -#foreach (_variableName ${_variableNames}) -# message(STATUS "${_variableName}=${${_variableName}}") -#endforeach() -#message(SEND_ERROR "${Boost_LIBRARIES}") -#message(SEND_ERROR "${WALLET_TARGETS} -# ${EXTRA_LIBS_WOWNEROSEED} -# ${EXTRA_LIBS_ANDROID}") - - -if (${HOST_ABI} STREQUAL "x86_64-w64-mingw32" OR - ${HOST_ABI} STREQUAL "i686-w64-mingw32") - target_link_options(wallet2_api_c PRIVATE "-Wl,--section-alignment,16384") +if (${HOST_ABI} MATCHES "-w64-mingw32") + target_link_options(${MONERO_FLAVOR}_wallet2_api_c PRIVATE "-Wl,--section-alignment,16384") elseif(${HOST_ABI} MATCHES "-linux-") - target_link_options(wallet2_api_c PRIVATE "-Wl,-z,max-page-size=16384") + target_link_options(${MONERO_FLAVOR}_wallet2_api_c PRIVATE "-Wl,-z,max-page-size=16384") endif() if(${HOST_ABI} MATCHES "-apple-") @@ -193,7 +140,7 @@ if(${HOST_ABI} MATCHES "-apple-") ) endif() -target_link_libraries( wallet2_api_c +target_link_libraries( ${MONERO_FLAVOR}_wallet2_api_c ${WALLET_TARGETS} ${EXTRA_LIBS_WOWNEROSEED} diff --git a/monero_libwallet2_api_c/monero_libwallet2_api_c.exp b/monero_libwallet2_api_c/monero_libwallet2_api_c.exp index 1aa2f26..0c59e1a 100644 --- a/monero_libwallet2_api_c/monero_libwallet2_api_c.exp +++ b/monero_libwallet2_api_c/monero_libwallet2_api_c.exp @@ -308,3 +308,43 @@ _MONERO_free _MONERO_checksum_wallet2_api_c_h _MONERO_checksum_wallet2_api_c_cpp _MONERO_checksum_wallet2_api_c_exp +_MONERO_NetworkType_MAINNET +_MONERO_NetworkType_TESTNET +_MONERO_NetworkType_STAGENET +_MONERO_PendingTransactionStatus_Ok +_MONERO_PendingTransactionStatus_Error +_MONERO_PendingTransactionStatus_Critical +_MONERO_Priority_Default +_MONERO_Priority_Low +_MONERO_Priority_Medium +_MONERO_Priority_High +_MONERO_Priority_Last +_MONERO_WalletDevice_Software +_MONERO_WalletDevice_Ledger +_MONERO_WalletDevice_Trezor +_MONERO_WalletStatus_Ok +_MONERO_WalletStatus_Error +_MONERO_WalletStatus_Critical +_MONERO_WalletConnectionStatus_Disconnected +_MONERO_WalletConnectionStatus_Connected +_MONERO_WalletConnectionStatus_WrongVersion +_MONERO_WalletBackgroundSync_Off +_MONERO_WalletBackgroundSync_ReusePassword +_MONERO_WalletBackgroundSync_CustomPassword +_MONERO_LogLevel_Silent +_MONERO_LogLevel_0 +_MONERO_LogLevel_1 +_MONERO_LogLevel_2 +_MONERO_LogLevel_3 +_MONERO_LogLevel_4 +_MONERO_LogLevel_Min +_MONERO_LogLevel_Max +_MONERO_UnsignedTransactionStatus_Ok +_MONERO_UnsignedTransactionStatus_Error +_MONERO_UnsignedTransactionStatus_Critical +_MONERO_TransactionInfoDirection_In +_MONERO_TransactionInfoDirection_Out +_MONERO_AddressBookErrorCodeStatus_Ok +_MONERO_AddressBookErrorCodeGeneral_Error +_MONERO_AddressBookErrorCodeInvalid_Address +_MONERO_AddressBookErrorCodeInvalidPaymentId diff --git a/monero_libwallet2_api_c/src/main/cpp/monero_checksum.c b/monero_libwallet2_api_c/src/main/cpp/monero_checksum.c new file mode 100644 index 0000000..36a251b --- /dev/null +++ b/monero_libwallet2_api_c/src/main/cpp/monero_checksum.c @@ -0,0 +1,5 @@ +#include "monero_checksum.h" + +const char * MONERO_wallet2_api_c_h_sha256 = "e7117f437964c7bd7dc90ced932432b4571113bd1e981238c689e297ec02a9e5"; +const char * MONERO_wallet2_api_c_cpp_sha256 = "8329ea5c29578a48cf8a15ebe4de693bc412b7b6fdc053290f8c4719ffad54d0-dbcc7d212c094bd1a45f7291dbb99a4b4627a96d"; +const char * MONERO_wallet2_api_c_exp_sha256 = "135c0e3c7088e43cfbbff00fc814addb8929a1116324a618c7276bd789b78563"; diff --git a/monero_libwallet2_api_c/src/main/cpp/monero_checksum.h b/monero_libwallet2_api_c/src/main/cpp/monero_checksum.h index 55acabb..2636eb1 100644 --- a/monero_libwallet2_api_c/src/main/cpp/monero_checksum.h +++ b/monero_libwallet2_api_c/src/main/cpp/monero_checksum.h @@ -1,6 +1,22 @@ #ifndef MONEROC_CHECKSUMS #define MONEROC_CHECKSUMS -const char * MONERO_wallet2_api_c_h_sha256 = "3515e4c9e537ca3efa664f0b364a3aeb106ff64337f542a262ce104c00b31235"; -const char * MONERO_wallet2_api_c_cpp_sha256 = "ca44a8d4a201ba6dc0a25c857e95d07bc8d514039b38cd5b3826100e8943cbcc-dbcc7d212c094bd1a45f7291dbb99a4b4627a96d"; -const char * MONERO_wallet2_api_c_exp_sha256 = "0561e14606106e6b0ec49fb2aefe743ff500f7c3de07557f7041e06aef9509ce"; +#ifdef __cplusplus +extern "C" +{ +#endif + +#ifdef __MINGW32__ + #define ADDAPI __declspec(dllexport) +#else + #define ADDAPI __attribute__((__visibility__("default"))) +#endif + +extern ADDAPI const char * MONERO_wallet2_api_c_h_sha256; +extern ADDAPI const char * MONERO_wallet2_api_c_cpp_sha256; +extern ADDAPI const char * MONERO_wallet2_api_c_exp_sha256; + +#ifdef __cplusplus +} +#endif + #endif diff --git a/monero_libwallet2_api_c/src/main/cpp/monero_wallet2_api_c.cpp b/monero_libwallet2_api_c/src/main/cpp/monero_wallet2_api_c.cpp new file mode 100644 index 0000000..ef48447 --- /dev/null +++ b/monero_libwallet2_api_c/src/main/cpp/monero_wallet2_api_c.cpp @@ -0,0 +1,2676 @@ +#include +#include "monero_wallet2_api_c.h" +#include +#include "helpers.hpp" +#include +#include +#include "../../../../monero/src/wallet/api/wallet2_api.h" +#include "monero_checksum.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + + +// The code in here consists of simple wrappers, that convert +// more advanced c++ types (and function names) into simple C-compatible +// functions, so these implementations can be easly used from all languages +// that do support C interop (such as dart) +// +// +// Here is the most complex definition that we can find in the current codebase, it even includes +// a if statement - which in general I consider an anti-patter in just wrappers +// +// _____________ void* because C++ wallet->createTransaction returns a pointer to Monero::PendingTransaction, which we don't want to have exposed in C land +// / _____________ MONERO prefix just means that this function is using monero codebase, to not cause any symbols collision when using more than one libwallet2_api_c.so in a single program. +// | / _____________ Wallet is one of the classes in Monero namespace in the upstream codebase (see the include line above) +// | | / _____________ aaand it is calling createTransaction function. +// | | | / _________________________________________________________________________________ +// | | | | / \ All of these parameters can be found in the upstream +// | | | | | _____________/ function definition, if something was more complex - +// void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, / like std::set I've used splitString functions and introduced a new +// uint64_t amount, uint32_t mixin_count, / parameter - separator, as it is the simplest way to get vector onto +// int pendingTransactionPriority, / C side from more advanced world. +// uint32_t subaddr_account, / +// const char* preferredInputs, const char* separator) { +// Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); <------------ We are converting the void* into Monero::Wallet* +// Monero::optional optAmount; <------------- optional by default +// if (amount != 0) {------------------\ We set this optional parameter only when it isn't zero +// optAmount = amount; | +// }___________________________________/ +// std::set subaddr_indices = {}; ------------- Default value +// std::set preferred_inputs = splitString(std::string(preferredInputs), std::string(separator)); <------------- We are using helpers.cpp function to split a string into std::set +// return wallet->createTransaction(std::string(dst_addr), std::string(payment_id),-\ const char * is getting casted onto std::string +// optAmount, mixin_count, \_____________/ +// PendingTransaction_Priority_fromInt(pendingTransactionPriority), <------------- special case for this function to get native type instead of int value. +// subaddr_account, subaddr_indices, preferred_inputs); +// } +// +// +// One case which is not covered here is when we have to return a string +// const char* MONERO_PendingTransaction_errorString(void* pendingTx_ptr) { +// Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); +// std::string str = pendingTx->errorString(); <------------- get the actual string from the upstream codebase +// const std::string::size_type size = str.size(); ------------------------------\ +// char *buffer = new char[size + 1]; //we need extra char for NUL | Copy the string onto a new memory so it won't get freed after the function returns +// memcpy(buffer, str.c_str(), size + 1); | NOTE: This requires us to call free() after we are done with the text processing +// return buffer; ______________________________________________________________/ +// } +// +// + +const int MONERO_NetworkType_MAINNET = 0; +const int MONERO_NetworkType_TESTNET = 1; +const int MONERO_NetworkType_STAGENET = 2; + +// PendingTransaction + +const int MONERO_PendingTransactionStatus_Ok = 0; +const int MONERO_PendingTransactionStatus_Error = 1; +const int MONERO_PendingTransactionStatus_Critical = 2; +const int MONERO_Priority_Default = 0; +const int MONERO_Priority_Low = 1; +const int MONERO_Priority_Medium = 2; +const int MONERO_Priority_High = 3; +const int MONERO_Priority_Last = 4; + +int MONERO_PendingTransaction_status(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->status(); + DEBUG_END() +} +const char* MONERO_PendingTransaction_errorString(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::string str = pendingTx->errorString(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +bool MONERO_PendingTransaction_commit(void* pendingTx_ptr, const char* filename, bool overwrite) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->commit(std::string(filename), overwrite); + DEBUG_END() +} +const char* MONERO_PendingTransaction_commitUR(void* pendingTx_ptr, int max_fragment_length) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::string str = pendingTx->commitUR(max_fragment_length); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +uint64_t MONERO_PendingTransaction_amount(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->amount(); + DEBUG_END() +} +uint64_t MONERO_PendingTransaction_dust(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->dust(); + DEBUG_END() +} +uint64_t MONERO_PendingTransaction_fee(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->fee(); + DEBUG_END() +} +const char* MONERO_PendingTransaction_txid(void* pendingTx_ptr, const char* separator) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::vector txid = pendingTx->txid(); + return vectorToString(txid, std::string(separator)); + DEBUG_END() +} +uint64_t MONERO_PendingTransaction_txCount(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->txCount(); + DEBUG_END() +} +const char* MONERO_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::vector subaddrAccount = pendingTx->subaddrAccount(); + return vectorToString(subaddrAccount, std::string(separator)); + DEBUG_END() +} +const char* MONERO_PendingTransaction_subaddrIndices(void* pendingTx_ptr, const char* separator) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::vector> subaddrIndices = pendingTx->subaddrIndices(); + return vectorToString(subaddrIndices, std::string(separator)); + DEBUG_END() +} +const char* MONERO_PendingTransaction_multisigSignData(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::string str = pendingTx->multisigSignData(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +void MONERO_PendingTransaction_signMultisigTx(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->signMultisigTx(); + DEBUG_END() +} +const char* MONERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::vector txid = pendingTx->signersKeys(); + return vectorToString(txid, std::string(separator)); + DEBUG_END() +} + +const char* MONERO_PendingTransaction_hex(void* pendingTx_ptr, const char* separator) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::vector txid = pendingTx->hex(); + return vectorToString(txid, std::string(separator)); + DEBUG_END() +} + +const char* MONERO_PendingTransaction_txKey(void* pendingTx_ptr, const char* separator) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::vector txid = pendingTx->txKey(); + return vectorToString(txid, std::string(separator)); + DEBUG_END() +} + +// UnsignedTransaction + +const int MONERO_UnsignedTransactionStatus_Ok = 0; +const int MONERO_UnsignedTransactionStatus_Error = 1; +const int MONERO_UnsignedTransactionStatus_Critical = 2; + +int MONERO_UnsignedTransaction_status(void* unsignedTx_ptr) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return unsignedTx->status(); + DEBUG_END() +} +const char* MONERO_UnsignedTransaction_errorString(void* unsignedTx_ptr) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + std::string str = unsignedTx->errorString(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +const char* MONERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return vectorToString(unsignedTx->amount(), std::string(separator)); + DEBUG_END() +} +const char* MONERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return vectorToString(unsignedTx->fee(), std::string(separator)); + DEBUG_END() +} +const char* MONERO_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return vectorToString(unsignedTx->mixin(), std::string(separator)); + DEBUG_END() +} +const char* MONERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + std::string str = unsignedTx->confirmationMessage(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +const char* MONERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return vectorToString(unsignedTx->paymentId(), std::string(separator)); + DEBUG_END() +} +const char* MONERO_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return vectorToString(unsignedTx->recipientAddress(), std::string(separator)); + DEBUG_END() +} +uint64_t MONERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return unsignedTx->minMixinCount(); + DEBUG_END() +} +uint64_t MONERO_UnsignedTransaction_txCount(void* unsignedTx_ptr) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return unsignedTx->txCount(); + DEBUG_END() +} +bool MONERO_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return unsignedTx->sign(std::string(signedFileName)); + DEBUG_END() +} +const char* MONERO_UnsignedTransaction_signUR(void* unsignedTx_ptr, int max_fragment_length) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + std::string str = unsignedTx->signUR(max_fragment_length); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// TransactionInfo + +const int MONERO_TransactionInfoDirection_In = 0; +const int MONERO_TransactionInfoDirection_Out = 1; +int MONERO_TransactionInfo_direction(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->direction(); + DEBUG_END() +} +bool MONERO_TransactionInfo_isPending(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->isPending(); + DEBUG_END() +} +bool MONERO_TransactionInfo_isFailed(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->isFailed(); + DEBUG_END() +} +bool MONERO_TransactionInfo_isCoinbase(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->isCoinbase(); + DEBUG_END() +} +uint64_t MONERO_TransactionInfo_amount(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->amount(); + DEBUG_END() +} +uint64_t MONERO_TransactionInfo_fee(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->fee(); + DEBUG_END() +} +uint64_t MONERO_TransactionInfo_blockHeight(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->blockHeight(); + DEBUG_END() +} +const char* MONERO_TransactionInfo_description(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + std::string str = txInfo->description(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +const char* MONERO_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + std::set subaddrIndex = txInfo->subaddrIndex(); + return vectorToString(subaddrIndex, std::string(separator)); + DEBUG_END() +} +uint32_t MONERO_TransactionInfo_subaddrAccount(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->subaddrAccount(); + DEBUG_END() +} +const char* MONERO_TransactionInfo_label(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + std::string str = txInfo->label(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +uint64_t MONERO_TransactionInfo_confirmations(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->confirmations(); + DEBUG_END() +} +uint64_t MONERO_TransactionInfo_unlockTime(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->unlockTime(); + DEBUG_END() +} +const char* MONERO_TransactionInfo_hash(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + std::string str = txInfo->hash(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +uint64_t MONERO_TransactionInfo_timestamp(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->timestamp(); + DEBUG_END() +} +const char* MONERO_TransactionInfo_paymentId(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + std::string str = txInfo->paymentId(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +int MONERO_TransactionInfo_transfers_count(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->transfers().size(); + DEBUG_END() +} + +uint64_t MONERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->transfers()[index].amount; + DEBUG_END() +} + +const char* MONERO_TransactionInfo_transfers_address(void* txInfo_ptr, int index) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + std::string str = txInfo->transfers()[index].address; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + + + + +// TransactionHistory +int MONERO_TransactionHistory_count(void* txHistory_ptr) { + DEBUG_START() + Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); + return txHistory->count(); + DEBUG_END() +} +void* MONERO_TransactionHistory_transaction(void* txHistory_ptr, int index) { + DEBUG_START() + Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); + return reinterpret_cast(txHistory->transaction(index)); + DEBUG_END() +} +void* MONERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id) { + DEBUG_START() + Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); + return reinterpret_cast(txHistory->transaction(std::string(id))); + DEBUG_END() +} + +void MONERO_TransactionHistory_refresh(void* txHistory_ptr) { + DEBUG_START() + Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); + return txHistory->refresh(); + DEBUG_END() +} +void MONERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note) { + DEBUG_START() + Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); + return txHistory->setTxNote(std::string(txid), std::string(note)); + DEBUG_END() +} + +// AddressBokRow + +// std::string extra; +const char* MONERO_AddressBookRow_extra(void* addressBookRow_ptr) { + DEBUG_START() + Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); + std::string str = addressBookRow->extra; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getAddress() const {return m_address;} +const char* MONERO_AddressBookRow_getAddress(void* addressBookRow_ptr) { + DEBUG_START() + Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); + std::string str = addressBookRow->getAddress(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getDescription() const {return m_description;} +const char* MONERO_AddressBookRow_getDescription(void* addressBookRow_ptr) { + DEBUG_START() + Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); + std::string str = addressBookRow->getDescription(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getPaymentId() const {return m_paymentId;} +const char* MONERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr) { + DEBUG_START() + Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); + std::string str = addressBookRow->getPaymentId(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::size_t getRowId() const {return m_rowId;} +size_t MONERO_AddressBookRow_getRowId(void* addressBookRow_ptr) { + DEBUG_START() + Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); + return addressBookRow->getRowId(); + DEBUG_END() +} + +// AddressBook + +const int MONERO_AddressBookErrorCodeStatus_Ok = 0; +const int MONERO_AddressBookErrorCodeGeneral_Error = 1; +const int MONERO_AddressBookErrorCodeInvalid_Address = 2; +const int MONERO_AddressBookErrorCodeInvalidPaymentId = 3; + +// virtual std::vector getAll() const = 0; +int MONERO_AddressBook_getAll_size(void* addressBook_ptr) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->getAll().size(); + DEBUG_END() +} +void* MONERO_AddressBook_getAll_byIndex(void* addressBook_ptr, int index) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->getAll()[index]; + DEBUG_END() +} +// virtual bool addRow(const std::string &dst_addr , const std::string &payment_id, const std::string &description) = 0; +bool MONERO_AddressBook_addRow(void* addressBook_ptr, const char* dst_addr , const char* payment_id, const char* description) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->addRow(std::string(dst_addr), std::string(payment_id), std::string(description)); + DEBUG_END() +} +// virtual bool deleteRow(std::size_t rowId) = 0; +bool MONERO_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->deleteRow(rowId); + DEBUG_END() +} +// virtual bool setDescription(std::size_t index, const std::string &description) = 0; +bool MONERO_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->setDescription(rowId, std::string(description)); + DEBUG_END() +} +// virtual void refresh() = 0; +void MONERO_AddressBook_refresh(void* addressBook_ptr) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->refresh(); + DEBUG_END() +} +// virtual std::string errorString() const = 0; +const char* MONERO_AddressBook_errorString(void* addressBook_ptr) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + std::string str = addressBook->errorString(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual int errorCode() const = 0; +int MONERO_AddressBook_errorCode(void* addressBook_ptr) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->errorCode(); + DEBUG_END() +} +// virtual int lookupPaymentID(const std::string &payment_id) const = 0; +int MONERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->lookupPaymentID(std::string(payment_id)); + DEBUG_END() +} + +// CoinsInfo +uint64_t MONERO_CoinsInfo_blockHeight(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->blockHeight(); + DEBUG_END() +} +// virtual std::string hash() const = 0; +const char* MONERO_CoinsInfo_hash(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + std::string str = coinsInfo->hash(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual size_t internalOutputIndex() const = 0; +size_t MONERO_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->internalOutputIndex(); + DEBUG_END() +} +// virtual uint64_t globalOutputIndex() const = 0; +uint64_t MONERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->globalOutputIndex(); + DEBUG_END() +} +// virtual bool spent() const = 0; +bool MONERO_CoinsInfo_spent(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->spent(); + DEBUG_END() +} +// virtual bool frozen() const = 0; +bool MONERO_CoinsInfo_frozen(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->frozen(); + DEBUG_END() +} +// virtual uint64_t spentHeight() const = 0; +uint64_t MONERO_CoinsInfo_spentHeight(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->spentHeight(); + DEBUG_END() +} +// virtual uint64_t amount() const = 0; +uint64_t MONERO_CoinsInfo_amount(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->amount(); + DEBUG_END() +} +// virtual bool rct() const = 0; +bool MONERO_CoinsInfo_rct(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->rct(); + DEBUG_END() +} +// virtual bool keyImageKnown() const = 0; +bool MONERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->keyImageKnown(); + DEBUG_END() +} +// virtual size_t pkIndex() const = 0; +size_t MONERO_CoinsInfo_pkIndex(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->pkIndex(); + DEBUG_END() +} +// virtual uint32_t subaddrIndex() const = 0; +uint32_t MONERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->subaddrIndex(); + DEBUG_END() +} +// virtual uint32_t subaddrAccount() const = 0; +uint32_t MONERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->subaddrAccount(); + DEBUG_END() +} +// virtual std::string address() const = 0; +const char* MONERO_CoinsInfo_address(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + std::string str = coinsInfo->address(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual std::string addressLabel() const = 0; +const char* MONERO_CoinsInfo_addressLabel(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + std::string str = coinsInfo->addressLabel(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual std::string keyImage() const = 0; +const char* MONERO_CoinsInfo_keyImage(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + std::string str = coinsInfo->keyImage(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual uint64_t unlockTime() const = 0; +uint64_t MONERO_CoinsInfo_unlockTime(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->unlockTime(); + DEBUG_END() +} +// virtual bool unlocked() const = 0; +bool MONERO_CoinsInfo_unlocked(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->unlocked(); + DEBUG_END() +} +// virtual std::string pubKey() const = 0; +const char* MONERO_CoinsInfo_pubKey(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + std::string str = coinsInfo->pubKey(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual bool coinbase() const = 0; +bool MONERO_CoinsInfo_coinbase(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->coinbase(); + DEBUG_END() +} +// virtual std::string description() const = 0; +const char* MONERO_CoinsInfo_description(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + std::string str = coinsInfo->description(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + + +// coins + +// virtual ~Coins() = 0; +// virtual int count() const = 0; +int MONERO_Coins_count(void* coins_ptr) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->count(); + DEBUG_END() +} +// virtual CoinsInfo * coin(int index) const = 0; +void* MONERO_Coins_coin(void* coins_ptr, int index) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->coin(index); + DEBUG_END() +} + +int MONERO_Coins_getAll_size(void* coins_ptr) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->getAll().size(); + DEBUG_END() +} +void* MONERO_Coins_getAll_byIndex(void* coins_ptr, int index) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->getAll()[index]; + DEBUG_END() +} + +// virtual std::vector getAll() const = 0; +// virtual void refresh() = 0; +void MONERO_Coins_refresh(void* coins_ptr) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->refresh(); + DEBUG_END() +} +// virtual void setFrozen(std::string public_key) = 0; +void MONERO_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->setFrozen(std::string(public_key)); + DEBUG_END() +} +// virtual void setFrozen(int index) = 0; +void MONERO_Coins_setFrozen(void* coins_ptr, int index) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->setFrozen(index); + DEBUG_END() +} +// virtual void thaw(int index) = 0; +void MONERO_Coins_thaw(void* coins_ptr, int index) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->thaw(index); + DEBUG_END() +} +// virtual void thaw(std::string public_key) = 0; +void MONERO_Coins_thawByPublicKey(void* coins_ptr, const char* public_key) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->thaw(std::string(public_key)); + DEBUG_END() +} +// virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0; +bool MONERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->isTransferUnlocked(unlockTime, blockHeight); + DEBUG_END() +} +// virtual void setDescription(const std::string &public_key, const std::string &description) = 0; +void MONERO_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->setDescription(std::string(public_key), std::string(description)); + DEBUG_END() +} + +// SubaddressRow + +// std::string extra; +const char* MONERO_SubaddressRow_extra(void* subaddressRow_ptr) { + DEBUG_START() + Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); + std::string str = subaddressRow->extra; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getAddress() const {return m_address;} +const char* MONERO_SubaddressRow_getAddress(void* subaddressRow_ptr) { + DEBUG_START() + Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); + std::string str = subaddressRow->getAddress(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getLabel() const {return m_label;} +const char* MONERO_SubaddressRow_getLabel(void* subaddressRow_ptr) { + DEBUG_START() + Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); + std::string str = subaddressRow->getLabel(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::size_t getRowId() const {return m_rowId;} +size_t MONERO_SubaddressRow_getRowId(void* subaddressRow_ptr) { + DEBUG_START() + Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); + return subaddressRow->getRowId(); + DEBUG_END() +} + +// Subaddress + +int MONERO_Subaddress_getAll_size(void* subaddress_ptr) { + DEBUG_START() + Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); + return subaddress->getAll().size(); + DEBUG_END() +} +void* MONERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index) { + DEBUG_START() + Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); + return subaddress->getAll()[index]; + DEBUG_END() +} +// virtual void addRow(uint32_t accountIndex, const std::string &label) = 0; +void MONERO_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label) { + DEBUG_START() + Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); + return subaddress->addRow(accountIndex, std::string(label)); + DEBUG_END() +} +// virtual void setLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0; +void MONERO_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label) { + DEBUG_START() + Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); + return subaddress->setLabel(accountIndex, addressIndex, std::string(label)); + DEBUG_END() +} +// virtual void refresh(uint32_t accountIndex) = 0; +void MONERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex) { + DEBUG_START() + Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); + return subaddress->refresh(accountIndex); + DEBUG_END() +} + +// SubaddressAccountRow + +// std::string extra; +const char* MONERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr) { + DEBUG_START() + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); + std::string str = subaddressAccountRow->extra; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getAddress() const {return m_address;} +const char* MONERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr) { + DEBUG_START() + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); + std::string str = subaddressAccountRow->getAddress(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getLabel() const {return m_label;} +const char* MONERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr) { + DEBUG_START() + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); + std::string str = subaddressAccountRow->getLabel(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getBalance() const {return m_balance;} +const char* MONERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr) { + DEBUG_START() + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); + std::string str = subaddressAccountRow->getBalance(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getUnlockedBalance() const {return m_unlockedBalance;} +const char* MONERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr) { + DEBUG_START() + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); + std::string str = subaddressAccountRow->getUnlockedBalance(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::size_t getRowId() const {return m_rowId;} +size_t MONERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr) { + DEBUG_START() + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); + return subaddressAccountRow->getRowId(); + DEBUG_END() +} + +// struct SubaddressAccount +// { +// virtual ~SubaddressAccount() = 0; +// virtual std::vector getAll() const = 0; +int MONERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr) { + DEBUG_START() + Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); + return subaddress->getAll().size(); + DEBUG_END() +} +void* MONERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index) { + DEBUG_START() + Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); + return subaddress->getAll()[index]; + DEBUG_END() +} +// virtual void addRow(const std::string &label) = 0; +void MONERO_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label) { + DEBUG_START() + Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); + return subaddress->addRow(std::string(label)); + DEBUG_END() +} +// virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0; +void MONERO_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label) { + DEBUG_START() + Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); + return subaddress->setLabel(accountIndex, std::string(label)); + DEBUG_END() +} +// virtual void refresh() = 0; +void MONERO_SubaddressAccount_refresh(void* subaddressAccount_ptr) { + DEBUG_START() + Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); + return subaddress->refresh(); + DEBUG_END() +} + +// MultisigState + +// bool isMultisig; +bool MONERO_MultisigState_isMultisig(void* multisigState_ptr) { + DEBUG_START() + Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); + return multisigState->isMultisig; + DEBUG_END() +} +// bool isReady; +bool MONERO_MultisigState_isReady(void* multisigState_ptr) { + DEBUG_START() + Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); + return multisigState->isReady; + DEBUG_END() +} +// uint32_t threshold; +uint32_t MONERO_MultisigState_threshold(void* multisigState_ptr) { + DEBUG_START() + Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); + return multisigState->threshold; + DEBUG_END() +} +// uint32_t total; +uint32_t MONERO_MultisigState_total(void* multisigState_ptr) { + DEBUG_START() + Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); + return multisigState->total; + DEBUG_END() +} + +// DeviceProgress + + +// virtual double progress() const { return m_progress; } +bool MONERO_DeviceProgress_progress(void* deviceProgress_ptr) { + DEBUG_START() + Monero::DeviceProgress *deviceProgress = reinterpret_cast(deviceProgress_ptr); + return deviceProgress->progress(); + DEBUG_END() +} +// virtual bool indeterminate() const { return m_indeterminate; } +bool MONERO_DeviceProgress_indeterminate(void* deviceProgress_ptr) { + DEBUG_START() + Monero::DeviceProgress *deviceProgress = reinterpret_cast(deviceProgress_ptr); + return deviceProgress->indeterminate(); + DEBUG_END() +} + +const int MONERO_WalletDevice_Software = 0; +const int MONERO_WalletDevice_Ledger = 1; +const int MONERO_WalletDevice_Trezor = 2; +const int MONERO_WalletStatus_Ok = 0; +const int MONERO_WalletStatus_Error = 1; +const int MONERO_WalletStatus_Critical = 2; +const int MONERO_WalletConnectionStatus_Disconnected = 0; +const int MONERO_WalletConnectionStatus_Connected = 1; +const int MONERO_WalletConnectionStatus_WrongVersion = 2; +const int MONERO_WalletBackgroundSync_Off = 0; +const int MONERO_WalletBackgroundSync_ReusePassword = 1; +const int MONERO_WalletBackgroundSync_CustomPassword = 2; + +// Wallet + +const char* MONERO_Wallet_seed(void* wallet_ptr, const char* seed_offset) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->seed(std::string(seed_offset)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* MONERO_Wallet_getSeedLanguage(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->getSeedLanguage(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +void MONERO_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setSeedLanguage(std::string(arg)); + DEBUG_END() +} + +int MONERO_Wallet_status(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->status(); + DEBUG_END() +} + +const char* MONERO_Wallet_errorString(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->errorString(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + + +bool MONERO_Wallet_setPassword(void* wallet_ptr, const char* password) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setPassword(std::string(password)); + DEBUG_END() +} + +const char* MONERO_Wallet_getPassword(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->getPassword(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +bool MONERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setDevicePin(std::string(pin)); + DEBUG_END() +} + +bool MONERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setDevicePassphrase(std::string(passphrase)); + DEBUG_END() +} + +const char* MONERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->address(accountIndex, addressIndex); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* MONERO_Wallet_path(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->path(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +int MONERO_Wallet_nettype(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->nettype(); + DEBUG_END() +} +uint8_t MONERO_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->useForkRules(version, early_blocks); + DEBUG_END() +} +const char* MONERO_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->integratedAddress(std::string(payment_id)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* MONERO_Wallet_secretViewKey(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->secretViewKey(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* MONERO_Wallet_publicViewKey(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->publicViewKey(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* MONERO_Wallet_secretSpendKey(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->secretSpendKey(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* MONERO_Wallet_publicSpendKey(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->publicSpendKey(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +const char* MONERO_Wallet_publicMultisigSignerKey(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->publicMultisigSignerKey(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +void MONERO_Wallet_stop(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->stop(); + DEBUG_END() +} + +bool MONERO_Wallet_store(void* wallet_ptr, const char* path) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->store(std::string(path)); + DEBUG_END() +} +const char* MONERO_Wallet_filename(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->filename(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +const char* MONERO_Wallet_keysFilename(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->keysFilename(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +// virtual bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit = 0, const std::string &daemon_username = "", const std::string &daemon_password = "", bool use_ssl = false, bool lightWallet = false, const std::string &proxy_address = "") = 0; +bool MONERO_Wallet_init(void* wallet_ptr, const char* daemon_address, uint64_t upper_transaction_size_limit, const char* daemon_username, const char* daemon_password, bool use_ssl, bool lightWallet, const char* proxy_address) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->init(std::string(daemon_address), upper_transaction_size_limit, std::string(daemon_username), std::string(daemon_password), use_ssl, lightWallet, std::string(proxy_address)); + DEBUG_END() +} +bool MONERO_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->createWatchOnly(std::string(path), std::string(password), std::string(language)); + DEBUG_END() +} + +void MONERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setRefreshFromBlockHeight(refresh_from_block_height); + DEBUG_END() +} + +uint64_t MONERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->getRefreshFromBlockHeight(); + DEBUG_END() +} + +void MONERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setRecoveringFromSeed(recoveringFromSeed); + DEBUG_END() +} +void MONERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setRecoveringFromDevice(recoveringFromDevice); + DEBUG_END() +} +void MONERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setSubaddressLookahead(major, minor); + DEBUG_END() +} + +bool MONERO_Wallet_connectToDaemon(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->connectToDaemon(); + DEBUG_END() +} +int MONERO_Wallet_connected(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->connected(); + DEBUG_END() +} +void MONERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setTrustedDaemon(arg); + DEBUG_END() +} +bool MONERO_Wallet_trustedDaemon(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->trustedDaemon(); + DEBUG_END() +} +bool MONERO_Wallet_setProxy(void* wallet_ptr, const char* address) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setProxy(std::string(address)); + DEBUG_END() +} + +const int MONERO_LogLevel_Silent = -1; +const int MONERO_LogLevel_0 = 0; +const int MONERO_LogLevel_1 = 1; +const int MONERO_LogLevel_2 = 2; +const int MONERO_LogLevel_3 = 3; +const int MONERO_LogLevel_4 = 4; +const int MONERO_LogLevel_Min = MONERO_LogLevel_Silent; +const int MONERO_LogLevel_Max = MONERO_LogLevel_4; + +uint64_t MONERO_Wallet_balance(void* wallet_ptr, uint32_t accountIndex) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->balance(accountIndex); + DEBUG_END() +} + +uint64_t MONERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->unlockedBalance(accountIndex); + DEBUG_END() +} + +uint64_t MONERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->viewOnlyBalance(accountIndex); + DEBUG_END() +} + +// TODO +bool MONERO_Wallet_watchOnly(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->watchOnly(); + DEBUG_END() +} +bool MONERO_Wallet_isDeterministic(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->isDeterministic(); + DEBUG_END() +} +uint64_t MONERO_Wallet_blockChainHeight(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->blockChainHeight(); + DEBUG_END() +} +uint64_t MONERO_Wallet_approximateBlockChainHeight(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->approximateBlockChainHeight(); + DEBUG_END() +} +uint64_t MONERO_Wallet_estimateBlockChainHeight(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->estimateBlockChainHeight(); + DEBUG_END() +} +uint64_t MONERO_Wallet_daemonBlockChainHeight(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->daemonBlockChainHeight(); + DEBUG_END() +} + +uint64_t MONERO_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->daemonBlockChainTargetHeight(); + DEBUG_END() +} +bool MONERO_Wallet_synchronized(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->synchronized(); + DEBUG_END() +} + +const char* MONERO_Wallet_displayAmount(uint64_t amount) { + DEBUG_START() + std::string str = Monero::Wallet::displayAmount(amount); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +// static uint64_t amountFromString(const std::string &amount); +uint64_t MONERO_Wallet_amountFromString(const char* amount) { + DEBUG_START() + return Monero::Wallet::amountFromString(amount); + DEBUG_END() +} +// static uint64_t amountFromDouble(double amount); +uint64_t MONERO_Wallet_amountFromDouble(double amount) { + DEBUG_START() + return Monero::Wallet::amountFromDouble(amount); + DEBUG_END() +} +// static std::string genPaymentId(); +const char* MONERO_Wallet_genPaymentId() { + DEBUG_START() + std::string str = Monero::Wallet::genPaymentId(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// static bool paymentIdValid(const std::string &paiment_id); +bool MONERO_Wallet_paymentIdValid(const char* paiment_id) { + DEBUG_START() + return Monero::Wallet::paymentIdValid(std::string(paiment_id)); + DEBUG_END() +} +bool MONERO_Wallet_addressValid(const char* str, int nettype) { + DEBUG_START() + // Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return Monero::Wallet::addressValid(std::string(str), nettype); + DEBUG_END() +} + +bool MONERO_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype) { + DEBUG_START() + std::string error; + return Monero::Wallet::keyValid(std::string(secret_key_string), std::string(address_string), isViewKey, nettype, error); + DEBUG_END() +} +const char* MONERO_Wallet_keyValid_error(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype) { + DEBUG_START() + std::string str; + Monero::Wallet::keyValid(std::string(secret_key_string), std::string(address_string), isViewKey, nettype, str); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() + +} +const char* MONERO_Wallet_paymentIdFromAddress(const char* strarg, int nettype) { + DEBUG_START() + std::string str = Monero::Wallet::paymentIdFromAddress(std::string(strarg), nettype); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +uint64_t MONERO_Wallet_maximumAllowedAmount() { + DEBUG_START() + return Monero::Wallet::maximumAllowedAmount(); + DEBUG_END() +} + +void MONERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->init(argv0, default_log_base_name, log_path, console); + DEBUG_END() +} +const char* MONERO_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string seed = ""; + std::string _passphrase = std::string(passphrase); + wallet->getPolyseed(seed, _passphrase); + std::string str = seed; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// static bool createPolyseed(std::string &seed_words, std::string &err, const std::string &language = "English"); +const char* MONERO_Wallet_createPolyseed(const char* language) { + DEBUG_START() + std::string seed_words = ""; + std::string err; + Monero::Wallet::createPolyseed(seed_words, err, std::string(language)); + std::string str = seed_words; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +void MONERO_Wallet_startRefresh(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->startRefresh(); + DEBUG_END() +} +void MONERO_Wallet_pauseRefresh(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->pauseRefresh(); + DEBUG_END() +} +bool MONERO_Wallet_refresh(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->refresh(); + DEBUG_END() +} +void MONERO_Wallet_refreshAsync(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->refreshAsync(); + DEBUG_END() +} +bool MONERO_Wallet_rescanBlockchain(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->rescanBlockchain(); + DEBUG_END() +} +void MONERO_Wallet_rescanBlockchainAsync(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->rescanBlockchainAsync(); + DEBUG_END() +} +void MONERO_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setAutoRefreshInterval(millis); + DEBUG_END() +} +int MONERO_Wallet_autoRefreshInterval(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->autoRefreshInterval(); + DEBUG_END() +} +void MONERO_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->addSubaddressAccount(std::string(label)); + DEBUG_END() +} +size_t MONERO_Wallet_numSubaddressAccounts(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->numSubaddressAccounts(); + DEBUG_END() +} +size_t MONERO_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->numSubaddresses(accountIndex); + DEBUG_END() +} +void MONERO_Wallet_addSubaddress(void* wallet_ptr, uint32_t accountIndex, const char* label) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->addSubaddress(accountIndex, std::string(label)); + DEBUG_END() +} +const char* MONERO_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->getSubaddressLabel(accountIndex, addressIndex); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +void MONERO_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setSubaddressLabel(accountIndex, addressIndex, std::string(label)); + DEBUG_END() +} + +void* MONERO_Wallet_multisig(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + Monero::MultisigState *mstate_ptr = new Monero::MultisigState(wallet->multisig()); + return reinterpret_cast(mstate_ptr); + DEBUG_END() +} + +const char* MONERO_Wallet_getMultisigInfo(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->getMultisigInfo(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* MONERO_Wallet_makeMultisig(void* wallet_ptr, const char* info, const char* info_separator, uint32_t threshold) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->makeMultisig(splitStringVector(std::string(info), std::string(info_separator)), threshold); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* MONERO_Wallet_exchangeMultisigKeys(void* wallet_ptr, const char* info, const char* info_separator, bool force_update_use_with_caution) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->exchangeMultisigKeys(splitStringVector(std::string(info), std::string(info_separator)), force_update_use_with_caution); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* MONERO_Wallet_exportMultisigImages(void* wallet_ptr, const char* separator) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str; + wallet->exportMultisigImages(str); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +size_t MONERO_Wallet_importMultisigImages(void* wallet_ptr, const char* info, const char* info_separator) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->importMultisigImages(splitStringVector(std::string(info), std::string(info_separator))); + DEBUG_END() +} + +size_t MONERO_Wallet_hasMultisigPartialKeyImages(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->hasMultisigPartialKeyImages(); + DEBUG_END() +} + +void* MONERO_Wallet_restoreMultisigTransaction(void* wallet_ptr, const char* signData) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return reinterpret_cast(wallet->restoreMultisigTransaction(std::string(signData))); + DEBUG_END() +} + + +Monero::PendingTransaction::Priority PendingTransaction_Priority_fromInt(int value) { + switch(value) { + case 0: return Monero::PendingTransaction::Priority::Priority_Default; + case 1: return Monero::PendingTransaction::Priority::Priority_Low; + case 2: return Monero::PendingTransaction::Priority::Priority_Medium; + case 3: return Monero::PendingTransaction::Priority::Priority_High; + default: return Monero::PendingTransaction::Priority::Priority_Default; + } +} + +void* MONERO_Wallet_createTransactionMultDest(void* wallet_ptr, const char* dst_addr_list, const char* dst_addr_list_separator, const char* payment_id, + bool amount_sweep_all, const char* amount_list, const char* amount_list_separator, uint32_t mixin_count, + int pendingTransactionPriority, + uint32_t subaddr_account, + const char* preferredInputs, const char* preferredInputs_separator) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::vector dst_addr = splitStringVector(std::string(dst_addr_list), std::string(dst_addr_list_separator)); + + Monero::optional> optAmount; + if (!amount_sweep_all) { + optAmount = splitStringUint(std::string(amount_list), std::string(amount_list_separator));; + } + std::set subaddr_indices = {}; + std::set preferred_inputs = splitString(std::string(preferredInputs), std::string(preferredInputs_separator)); + + return wallet->createTransactionMultDest( + dst_addr, std::string(payment_id), + optAmount, mixin_count, + PendingTransaction_Priority_fromInt(pendingTransactionPriority), + subaddr_account, + subaddr_indices, + preferred_inputs + ); + DEBUG_END() +} + +void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, + uint64_t amount, uint32_t mixin_count, + int pendingTransactionPriority, + uint32_t subaddr_account, + const char* preferredInputs, const char* separator) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + Monero::optional optAmount; + if (amount != 0) { + optAmount = amount; + } + std::set subaddr_indices = {}; + std::set preferred_inputs = splitString(std::string(preferredInputs), std::string(separator)); + return wallet->createTransaction(std::string(dst_addr), std::string(payment_id), + optAmount, mixin_count, + PendingTransaction_Priority_fromInt(pendingTransactionPriority), + subaddr_account, subaddr_indices, preferred_inputs); + DEBUG_END() +} + +void* MONERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* fileName) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->loadUnsignedTx(std::string(fileName)); + DEBUG_END() +} + +void* MONERO_Wallet_loadUnsignedTxUR(void* wallet_ptr, const char* input) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->loadUnsignedTxUR(std::string(input)); + DEBUG_END() +} +bool MONERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->submitTransaction(std::string(fileName)); + DEBUG_END() +} +bool MONERO_Wallet_submitTransactionUR(void* wallet_ptr, const char* input) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->submitTransactionUR(std::string(input)); + DEBUG_END() +} +bool MONERO_Wallet_hasUnknownKeyImages(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->hasUnknownKeyImages(); + DEBUG_END() +} +bool MONERO_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->exportKeyImages(std::string(filename), all); + DEBUG_END() +} + +const char* MONERO_Wallet_exportKeyImagesUR(void* wallet_ptr, size_t max_fragment_length, bool all) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->exportKeyImagesUR(max_fragment_length, all); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +bool MONERO_Wallet_importKeyImages(void* wallet_ptr, const char* filename) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->importKeyImages(std::string(filename)); + DEBUG_END() +} +bool MONERO_Wallet_importKeyImagesUR(void* wallet_ptr, const char* input) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->importKeyImagesUR(std::string(input)); + DEBUG_END() +} +bool MONERO_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool all) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->exportOutputs(std::string(filename), all); + DEBUG_END() +} +const char* MONERO_Wallet_exportOutputsUR(void* wallet_ptr, size_t max_fragment_length, bool all) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->exportOutputsUR(max_fragment_length, all); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +bool MONERO_Wallet_importOutputs(void* wallet_ptr, const char* filename) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->importOutputs(std::string(filename)); + DEBUG_END() +} +bool MONERO_Wallet_importOutputsUR(void* wallet_ptr, const char* input) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->importOutputsUR(std::string(input)); + DEBUG_END() +} +// virtual bool setupBackgroundSync(const BackgroundSyncType background_sync_type, const std::string &wallet_password, const optional &background_cache_password) = 0; +bool MONERO_Wallet_setupBackgroundSync(void* wallet_ptr, int background_sync_type, const char* wallet_password, const char* background_cache_password) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setupBackgroundSync(Monero::Wallet::BackgroundSyncType::BackgroundSync_CustomPassword, std::string(wallet_password), std::string(background_cache_password)); + DEBUG_END() +} +// virtual BackgroundSyncType getBackgroundSyncType() const = 0; +int MONERO_Wallet_getBackgroundSyncType(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->getBackgroundSyncType(); + DEBUG_END() +} +// virtual bool startBackgroundSync() = 0; +bool MONERO_Wallet_startBackgroundSync(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->startBackgroundSync(); + DEBUG_END() +} +// virtual bool stopBackgroundSync(const std::string &wallet_password) = 0; +bool MONERO_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->stopBackgroundSync(std::string(wallet_password)); + DEBUG_END() +} +// virtual bool isBackgroundSyncing() const = 0; +bool MONERO_Wallet_isBackgroundSyncing(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->hasUnknownKeyImages(); + DEBUG_END() +} +// virtual bool isBackgroundWallet() const = 0; +bool MONERO_Wallet_isBackgroundWallet(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->isBackgroundWallet(); + DEBUG_END() +} +void* MONERO_Wallet_history(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->history(); + DEBUG_END() +} +void* MONERO_Wallet_addressBook(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->addressBook(); + DEBUG_END() +} +// virtual Coins * coins() = 0; +void* MONERO_Wallet_coins(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->coins(); + DEBUG_END() +} +// virtual Subaddress * subaddress() = 0; +void* MONERO_Wallet_subaddress(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->subaddress(); + DEBUG_END() +} +// virtual SubaddressAccount * subaddressAccount() = 0; +void* MONERO_Wallet_subaddressAccount(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->subaddressAccount(); + DEBUG_END() +} +// virtual uint32_t defaultMixin() const = 0; +uint32_t MONERO_Wallet_defaultMixin(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->defaultMixin(); + DEBUG_END() +} +// virtual void setDefaultMixin(uint32_t arg) = 0; +void MONERO_Wallet_setDefaultMixin(void* wallet_ptr, uint32_t arg) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setDefaultMixin(arg); + DEBUG_END() +} +// virtual bool setCacheAttribute(const std::string &key, const std::string &val) = 0; +bool MONERO_Wallet_setCacheAttribute(void* wallet_ptr, const char* key, const char* val) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setCacheAttribute(std::string(key), std::string(val)); + DEBUG_END() +} +// virtual std::string getCacheAttribute(const std::string &key) const = 0; +const char* MONERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->getCacheAttribute(std::string(key)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual bool setUserNote(const std::string &txid, const std::string ¬e) = 0; +bool MONERO_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setUserNote(std::string(txid), std::string(note)); + DEBUG_END() +} +// virtual std::string getUserNote(const std::string &txid) const = 0; +const char* MONERO_Wallet_getUserNote(void* wallet_ptr, const char* txid) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->getUserNote(std::string(txid)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* MONERO_Wallet_getTxKey(void* wallet_ptr, const char* txid) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->getTxKey(std::string(txid)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* MONERO_Wallet_signMessage(void* wallet_ptr, const char* message, const char* address) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->signMessage(std::string(message), std::string(address)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +bool MONERO_Wallet_verifySignedMessage(void* wallet_ptr, const char* message, const char* address, const char* signature) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + bool v = wallet->verifySignedMessage(std::string(message), std::string(address), std::string(signature)); + return v; + DEBUG_END() +} + +bool MONERO_Wallet_rescanSpent(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->rescanSpent(); + DEBUG_END() +} + +void MONERO_Wallet_setOffline(void* wallet_ptr, bool offline) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setOffline(offline); + DEBUG_END() +} +// virtual bool isOffline() const = 0; +bool MONERO_Wallet_isOffline(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->isOffline(); + DEBUG_END() +} + +void MONERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->segregatePreForkOutputs(segregate); + DEBUG_END() +} +// virtual void segregationHeight(uint64_t height) = 0; +void MONERO_Wallet_segregationHeight(void* wallet_ptr, uint64_t height) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->segregationHeight(height); + DEBUG_END() +} +// virtual void keyReuseMitigation2(bool mitigation) = 0; +void MONERO_Wallet_keyReuseMitigation2(void* wallet_ptr, bool mitigation) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->keyReuseMitigation2(mitigation); + DEBUG_END() +} +// virtual bool lightWalletLogin(bool &isNewWallet) const = 0; +// virtual bool lightWalletImportWalletRequest(std::string &payment_id, uint64_t &fee, bool &new_request, bool &request_fulfilled, std::string &payment_address, std::string &status) = 0; +// virtual bool lockKeysFile() = 0; +bool MONERO_Wallet_lockKeysFile(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->lockKeysFile(); + DEBUG_END() +} +// virtual bool unlockKeysFile() = 0; +bool MONERO_Wallet_unlockKeysFile(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->unlockKeysFile(); + DEBUG_END() +} +// virtual bool isKeysFileLocked() = 0; +bool MONERO_Wallet_isKeysFileLocked(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->isKeysFileLocked(); + DEBUG_END() +} +// virtual Device getDeviceType() const = 0; +int MONERO_Wallet_getDeviceType(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->getDeviceType(); + DEBUG_END() +} +// virtual uint64_t coldKeyImageSync(uint64_t &spent, uint64_t &unspent) = 0; +uint64_t MONERO_Wallet_coldKeyImageSync(void* wallet_ptr, uint64_t spent, uint64_t unspent) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->coldKeyImageSync(spent, unspent); + DEBUG_END() +} +// virtual void deviceShowAddress(uint32_t accountIndex, uint32_t addressIndex, const std::string &paymentId) = 0; +const char* MONERO_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = ""; + wallet->deviceShowAddress(accountIndex, addressIndex, str); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual bool reconnectDevice() = 0; +bool MONERO_Wallet_reconnectDevice(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->reconnectDevice(); + DEBUG_END() +}; + +uint64_t MONERO_Wallet_getBytesReceived(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->getBytesReceived(); + DEBUG_END() +} +uint64_t MONERO_Wallet_getBytesSent(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->getBytesSent(); + DEBUG_END() +} + +bool MONERO_Wallet_getStateIsConnected() { + DEBUG_START() + return Monero::Wallet::getStateIsConnected(); + DEBUG_END() +} + +unsigned char* MONERO_Wallet_getSendToDevice() { + DEBUG_START() + return Monero::Wallet::getSendToDevice(); + DEBUG_END() +} + +size_t MONERO_Wallet_getSendToDeviceLength() { + DEBUG_START() + return Monero::Wallet::getSendToDeviceLength(); + DEBUG_END() +} + +unsigned char* MONERO_Wallet_getReceivedFromDevice() { + DEBUG_START() + return Monero::Wallet::getReceivedFromDevice(); + DEBUG_END() +} + +size_t MONERO_Wallet_getReceivedFromDeviceLength() { + DEBUG_START() + return Monero::Wallet::getReceivedFromDeviceLength(); + DEBUG_END() +} + +bool MONERO_Wallet_getWaitsForDeviceSend() { + DEBUG_START() + return Monero::Wallet::getWaitsForDeviceSend(); + DEBUG_END() +} + +bool MONERO_Wallet_getWaitsForDeviceReceive() { + DEBUG_START() + return Monero::Wallet::getWaitsForDeviceReceive(); + DEBUG_END() +} + +void MONERO_Wallet_setDeviceReceivedData(unsigned char* data, size_t len) { + DEBUG_START() + Monero::Wallet::setDeviceReceivedData(data, len); + DEBUG_END() +} + +void MONERO_Wallet_setDeviceSendData(unsigned char* data, size_t len) { + DEBUG_START() + Monero::Wallet::setDeviceSendData(data, len); + DEBUG_END() +} + +void MONERO_Wallet_setLedgerCallback(void (*sendToLedgerDevice)(unsigned char *command, unsigned int cmd_len)) { + DEBUG_START() + Monero::Wallet::setLedgerCallback(sendToLedgerDevice); + DEBUG_END() +} + +const char* MONERO_Wallet_serializeCacheToJson(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string result = wallet->serializeCacheToJson(); + return strdup(result.c_str()); + DEBUG_END() +} + +void* MONERO_WalletManager_createWallet(void* wm_ptr, const char* path, const char* password, const char* language, int networkType) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + Monero::Wallet *wallet = wm->createWallet( + std::string(path), + std::string(password), + std::string(language), + static_cast(networkType)); + return reinterpret_cast(wallet); + DEBUG_END() +} + +void* MONERO_WalletManager_openWallet(void* wm_ptr, const char* path, const char* password, int networkType) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + Monero::Wallet *wallet = wm->openWallet( + std::string(path), + std::string(password), + static_cast(networkType)); + return reinterpret_cast(wallet); + DEBUG_END() +} +void* MONERO_WalletManager_recoveryWallet(void* wm_ptr, const char* path, const char* password, const char* mnemonic, int networkType, uint64_t restoreHeight, uint64_t kdfRounds, const char* seedOffset) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + // (const std::string &path, const std::string &password, const std::string &mnemonic, + // NetworkType nettype = MAINNET, uint64_t restoreHeight = 0, uint64_t kdf_rounds = 1, + // const std::string &seed_offset = {}) + Monero::Wallet *wallet = wm->recoveryWallet( + std::string(path), + std::string(password), + std::string(mnemonic), + static_cast(networkType), + restoreHeight, + kdfRounds, + std::string(seedOffset)); + return reinterpret_cast(wallet); + DEBUG_END() +} +// virtual Wallet * createWalletFromKeys(const std::string &path, +// const std::string &password, +// const std::string &language, +// NetworkType nettype, +// uint64_t restoreHeight, +// const std::string &addressString, +// const std::string &viewKeyString, +// const std::string &spendKeyString = "", +// uint64_t kdf_rounds = 1) = 0; +void* MONERO_WalletManager_createWalletFromKeys(void* wm_ptr, const char* path, const char* password, const char* language, int nettype, uint64_t restoreHeight, const char* addressString, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + Monero::Wallet *wallet = wm->createWalletFromKeys( + std::string(path), + std::string(password), + std::string(language), + static_cast(nettype), + restoreHeight, + std::string(addressString), + std::string(viewKeyString), + std::string(spendKeyString)); + return reinterpret_cast(wallet); + DEBUG_END() +} + +void* MONERO_WalletManager_createWalletFromDevice(void* wm_ptr, const char* path, const char* password, int nettype, const char* deviceName, uint64_t restoreHeight, const char* subaddressLookahead, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + Monero::Wallet *wallet = wm->createWalletFromDevice(std::string(path), + std::string(password), + static_cast(nettype), + std::string(deviceName), + restoreHeight, + std::string(subaddressLookahead), + kdf_rounds); + return reinterpret_cast(wallet); + DEBUG_END() +} + +void* MONERO_WalletManager_createDeterministicWalletFromSpendKey(void* wm_ptr, const char* path, const char* password, + const char* language, int nettype, uint64_t restoreHeight, + const char* spendKeyString, uint64_t kdf_rounds) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + Monero::Wallet *wallet = wm->createDeterministicWalletFromSpendKey( + std::string(path), + std::string(password), + std::string(language), + static_cast(nettype), + restoreHeight, + std::string(spendKeyString), + kdf_rounds + ); + return reinterpret_cast(wallet); + DEBUG_END() +} + +void* MONERO_WalletManager_createWalletFromPolyseed(void* wm_ptr, const char* path, const char* password, + int nettype, const char* mnemonic, const char* passphrase, + bool newWallet, uint64_t restore_height, uint64_t kdf_rounds) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->createWalletFromPolyseed(std::string(path), + std::string(password), + static_cast(nettype), + std::string(mnemonic), + std::string(passphrase), + newWallet, + restore_height, + kdf_rounds); + DEBUG_END() +} + + +bool MONERO_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wm->closeWallet(wallet, store); + DEBUG_END() +} + +bool MONERO_WalletManager_walletExists(void* wm_ptr, const char* path) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->walletExists(std::string(path)); + DEBUG_END() +} + +// virtual bool verifyWalletPassword(const std::string &keys_file_name, const std::string &password, bool no_spend_key, uint64_t kdf_rounds = 1) const = 0; +bool MONERO_WalletManager_verifyWalletPassword(void* wm_ptr, const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->verifyWalletPassword(std::string(keys_file_name), std::string(password), no_spend_key, kdf_rounds); + DEBUG_END() +} + +// virtual bool queryWalletDevice(Wallet::Device& device_type, const std::string &keys_file_name, const std::string &password, uint64_t kdf_rounds = 1) const = 0; +int MONERO_WalletManager_queryWalletDevice(void* wm_ptr, const char* keys_file_name, const char* password, uint64_t kdf_rounds) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + Monero::Wallet::Device device_type; + wm->queryWalletDevice(device_type, std::string(keys_file_name), std::string(password), kdf_rounds); + return device_type; + DEBUG_END() +} + +// virtual std::vector findWallets(const std::string &path) = 0; +const char* MONERO_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return vectorToString(wm->findWallets(std::string(path)), std::string(separator)); + DEBUG_END() +} + + +const char* MONERO_WalletManager_errorString(void* wm_ptr) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + std::string str = wm->errorString(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +void MONERO_WalletManager_setDaemonAddress(void* wm_ptr, const char* address) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->setDaemonAddress(std::string(address)); + DEBUG_END() +} + +bool MONERO_WalletManager_setProxy(void* wm_ptr, const char* address) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->setProxy(std::string(address)); + DEBUG_END() +} + + +// virtual bool connected(uint32_t *version = NULL) = 0; +// virtual uint64_t blockchainHeight() = 0; +uint64_t MONERO_WalletManager_blockchainHeight(void* wm_ptr) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->blockchainHeight(); + DEBUG_END() +} +// virtual uint64_t blockchainTargetHeight() = 0; +uint64_t MONERO_WalletManager_blockchainTargetHeight(void* wm_ptr) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->blockchainTargetHeight(); + DEBUG_END() +} +// virtual uint64_t networkDifficulty() = 0; +uint64_t MONERO_WalletManager_networkDifficulty(void* wm_ptr) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->networkDifficulty(); + DEBUG_END() +} +// virtual double miningHashRate() = 0; +double MONERO_WalletManager_miningHashRate(void* wm_ptr) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->miningHashRate(); + DEBUG_END() +} +// virtual uint64_t blockTarget() = 0; +uint64_t MONERO_WalletManager_blockTarget(void* wm_ptr) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->blockTarget(); + DEBUG_END() +} +// virtual bool isMining() = 0; +bool MONERO_WalletManager_isMining(void* wm_ptr) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->isMining(); + DEBUG_END() +} +// virtual bool startMining(const std::string &address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true) = 0; +bool MONERO_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->startMining(std::string(address), threads, backgroundMining, ignoreBattery); + DEBUG_END() +} +// virtual bool stopMining() = 0; +bool MONERO_WalletManager_stopMining(void* wm_ptr, const char* address) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->stopMining(); + DEBUG_END() +} +// virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0; +const char* MONERO_WalletManager_resolveOpenAlias(void* wm_ptr, const char* address, bool dnssec_valid) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + std::string str = wm->resolveOpenAlias(std::string(address), dnssec_valid); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +// WalletManagerFactory + +void* MONERO_WalletManagerFactory_getWalletManager() { + DEBUG_START() + Monero::WalletManager *wm = Monero::WalletManagerFactory::getWalletManager(); + return reinterpret_cast(wm); + DEBUG_END() +} + +void MONERO_WalletManagerFactory_setLogLevel(int level) { + DEBUG_START() + return Monero::WalletManagerFactory::setLogLevel(level); + DEBUG_END() +} + +void MONERO_WalletManagerFactory_setLogCategories(const char* categories) { + DEBUG_START() + return Monero::WalletManagerFactory::setLogCategories(std::string(categories)); + DEBUG_END() +} + +// DEBUG functions + +// As it turns out we need a bit more functions to make sure that the library is working. +// 0) void +// 1) bool +// 2) int +// 3) uint64_t +// 4) void* +// 5) const char* + +void MONERO_DEBUG_test0() { + return; +} + +bool MONERO_DEBUG_test1(bool x) { + return x; +} + +int MONERO_DEBUG_test2(int x) { + return x; +} + +uint64_t MONERO_DEBUG_test3(uint64_t x) { + return x; +} + +void* MONERO_DEBUG_test4(uint64_t x) { + int *y = new int(x); + return reinterpret_cast(y); +} + +const char* MONERO_DEBUG_test5() { + const char *text = "This is a const char* text"; + return text; +} + +const char* MONERO_DEBUG_test5_std() { + std::string text("This is a std::string text"); + const char *text2 = "This is a text"; + return text2; +} + +bool MONERO_DEBUG_isPointerNull(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return (wallet != NULL); + DEBUG_END() +} + +// cake wallet world +// TODO(mrcyjanek): https://api.dart.dev/stable/3.3.3/dart-ffi/Pointer/fromFunction.html +// callback to dart should be possible..? I mean why not? But I need to +// wait for other implementation (Go preferably) to see if this approach +// will work as expected. +struct MONERO_cw_WalletListener; +struct MONERO_cw_WalletListener : Monero::WalletListener +{ + uint64_t m_height; + bool m_need_to_refresh; + bool m_new_transaction; + + MONERO_cw_WalletListener() + { + m_height = 0; + m_need_to_refresh = false; + m_new_transaction = false; + } + + void moneySpent(const std::string &txId, uint64_t amount) + { + m_new_transaction = true; + } + + void moneyReceived(const std::string &txId, uint64_t amount) + { + m_new_transaction = true; + } + + void unconfirmedMoneyReceived(const std::string &txId, uint64_t amount) + { + m_new_transaction = true; + } + + void newBlock(uint64_t height) + { + m_height = height; + } + + void updated() + { + m_new_transaction = true; + } + + void refreshed() + { + m_need_to_refresh = true; + } + + + void cw_resetNeedToRefresh() + { + m_need_to_refresh = false; + } + + bool cw_isNeedToRefresh() + { + return m_need_to_refresh; + } + + bool cw_isNewTransactionExist() + { + return m_new_transaction; + } + + void cw_resetIsNewTransactionExist() + { + m_new_transaction = false; + } + + uint64_t cw_height() + { + return m_height; + } +}; + +void* MONERO_cw_getWalletListener(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + MONERO_cw_WalletListener *listener = new MONERO_cw_WalletListener(); + wallet->setListener(listener); + return reinterpret_cast(listener); + DEBUG_END() +} + +void MONERO_cw_WalletListener_resetNeedToRefresh(void* cw_walletListener_ptr) { + DEBUG_START() + MONERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); + listener->cw_resetNeedToRefresh(); + DEBUG_END() +} + +bool MONERO_cw_WalletListener_isNeedToRefresh(void* cw_walletListener_ptr) { + DEBUG_START() + MONERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); + return listener->cw_isNeedToRefresh(); + DEBUG_END() +}; + +bool MONERO_cw_WalletListener_isNewTransactionExist(void* cw_walletListener_ptr) { + DEBUG_START() + MONERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); + return listener->cw_isNeedToRefresh(); + DEBUG_END() +}; + +void MONERO_cw_WalletListener_resetIsNewTransactionExist(void* cw_walletListener_ptr) { + DEBUG_START() + MONERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); + listener->cw_isNeedToRefresh(); + DEBUG_END() +}; + +uint64_t MONERO_cw_WalletListener_height(void* cw_walletListener_ptr) { + DEBUG_START() + MONERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); + return listener->cw_isNeedToRefresh(); + DEBUG_END() +}; + +const char* MONERO_checksum_wallet2_api_c_h() { + return MONERO_wallet2_api_c_h_sha256; +} +const char* MONERO_checksum_wallet2_api_c_cpp() { + return MONERO_wallet2_api_c_cpp_sha256; +} +const char* MONERO_checksum_wallet2_api_c_exp() { + return MONERO_wallet2_api_c_exp_sha256; +} +// i hate windows + +void MONERO_free(void* ptr) { + free(ptr); +} + +#ifdef __cplusplus +} +#endif diff --git a/monero_libwallet2_api_c/src/main/cpp/monero_wallet2_api_c.h b/monero_libwallet2_api_c/src/main/cpp/monero_wallet2_api_c.h new file mode 100644 index 0000000..39bca89 --- /dev/null +++ b/monero_libwallet2_api_c/src/main/cpp/monero_wallet2_api_c.h @@ -0,0 +1,1049 @@ +/* +#include + +#define LOG_TAG "[NDK]" +#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__) +#define LOGW(...) __android_log_print(ANDROID_LOG_WARN,LOG_TAG,__VA_ARGS__) +#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__) +*/ + +#ifndef MONERO_LIBWALLET2_API_C_H +#define MONERO_LIBWALLET2_API_C_H + + +#include +#include +#include +#include +#include "monero_checksum.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + +#ifdef __MINGW32__ + #define ADDAPI __declspec(dllexport) +#else + #define ADDAPI __attribute__((__visibility__("default"))) +#endif + +// namespace Monero { +// enum NetworkType : uint8_t { +// MAINNET = 0, +extern ADDAPI const int MONERO_NetworkType_MAINNET; +// TESTNET, +extern ADDAPI const int MONERO_NetworkType_TESTNET; +// STAGENET +extern ADDAPI const int MONERO_NetworkType_STAGENET; +// }; +// namespace Utils { +// bool isAddressLocal(const std::string &hostaddr); +// void onStartup(); +// } +// template +// class optional { +// public: +// optional(): set(false) {} +// optional(const T &t): t(t), set(true) {} +// const T &operator*() const { return t; } +// T &operator*() { return t; } +// operator bool() const { return set; } +// private: +// T t; +// bool set; +// }; + +// struct PendingTransaction +// { +// enum Status { +// Status_Ok, +extern ADDAPI const int MONERO_PendingTransactionStatus_Ok; +// Status_Error, +extern ADDAPI const int MONERO_PendingTransactionStatus_Error; +// Status_Critical +extern ADDAPI const int MONERO_PendingTransactionStatus_Critical; +// }; +// enum Priority { +// Priority_Default = 0, +extern ADDAPI const int MONERO_Priority_Default; +// Priority_Low = 1, +extern ADDAPI const int MONERO_Priority_Low; +// Priority_Medium = 2, +extern ADDAPI const int MONERO_Priority_Medium; +// Priority_High = 3, +extern ADDAPI const int MONERO_Priority_High; +// Priority_Last +extern ADDAPI const int MONERO_Priority_Last; +// }; +// virtual ~PendingTransaction() = 0; +// virtual int status() const = 0; +extern ADDAPI int MONERO_PendingTransaction_status(void* pendingTx_ptr); +// virtual std::string errorString() const = 0; +extern ADDAPI const char* MONERO_PendingTransaction_errorString(void* pendingTx_ptr); +// virtual bool commit(const std::string &filename = "", bool overwrite = false) = 0; +extern ADDAPI bool MONERO_PendingTransaction_commit(void* pendingTx_ptr, const char* filename, bool overwrite); +extern ADDAPI const char* MONERO_PendingTransaction_commitUR(void* pendingTx_ptr, int max_fragment_length); +// virtual uint64_t amount() const = 0; +extern ADDAPI uint64_t MONERO_PendingTransaction_amount(void* pendingTx_ptr); +// virtual uint64_t dust() const = 0; +extern ADDAPI uint64_t MONERO_PendingTransaction_dust(void* pendingTx_ptr); +// virtual uint64_t fee() const = 0; +extern ADDAPI uint64_t MONERO_PendingTransaction_fee(void* pendingTx_ptr); +// virtual std::vector txid() const = 0; +extern ADDAPI const char* MONERO_PendingTransaction_txid(void* pendingTx_ptr, const char* separator); +// virtual uint64_t txCount() const = 0; +extern ADDAPI uint64_t MONERO_PendingTransaction_txCount(void* pendingTx_ptr); +// virtual std::vector subaddrAccount() const = 0; +extern ADDAPI const char* MONERO_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator); +// virtual std::vector> subaddrIndices() const = 0; +extern ADDAPI const char* MONERO_PendingTransaction_subaddrIndices(void* pendingTx_ptr, const char* separator); +// virtual std::string multisigSignData() = 0; +extern ADDAPI const char* MONERO_PendingTransaction_multisigSignData(void* pendingTx_ptr); +// virtual void signMultisigTx() = 0; +extern ADDAPI void MONERO_PendingTransaction_signMultisigTx(void* pendingTx_ptr); +// virtual std::vector signersKeys() const = 0; +extern ADDAPI const char* MONERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator); +// virtual std::vector hex() const = 0; +extern ADDAPI const char* MONERO_PendingTransaction_hex(void* pendingTx_ptr, const char* separator); +// virtual std::vector txKey() const = 0; +// extern ADDAPI const char* MONERO_PendingTransaction_txHex(void* pendingTx_ptr, const char* separator); +// }; + +// struct UnsignedTransaction +// { +// enum Status { +// Status_Ok, +extern ADDAPI const int MONERO_UnsignedTransactionStatus_Ok; +// Status_Error, +extern ADDAPI const int MONERO_UnsignedTransactionStatus_Error; +// Status_Critical +extern ADDAPI const int MONERO_UnsignedTransactionStatus_Critical; +// }; +// virtual ~UnsignedTransaction() = 0; +// virtual int status() const = 0; +extern ADDAPI int MONERO_UnsignedTransaction_status(void* unsignedTx_ptr); +// virtual std::string errorString() const = 0; +extern ADDAPI const char* MONERO_UnsignedTransaction_errorString(void* unsignedTx_ptr); +// virtual std::vector amount() const = 0; +extern ADDAPI const char* MONERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator); +// virtual std::vector fee() const = 0; +extern ADDAPI const char* MONERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator); +// virtual std::vector mixin() const = 0; +extern ADDAPI const char* MONERO_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator); +// virtual std::string confirmationMessage() const = 0; +extern ADDAPI const char* MONERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr); +// virtual std::vector paymentId() const = 0; +extern ADDAPI const char* MONERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator); +// virtual std::vector recipientAddress() const = 0; +extern ADDAPI const char* MONERO_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator); +// virtual uint64_t minMixinCount() const = 0; +extern ADDAPI uint64_t MONERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr); +// virtual uint64_t txCount() const = 0; +extern ADDAPI uint64_t MONERO_UnsignedTransaction_txCount(void* unsignedTx_ptr); +// virtual bool sign(const std::string &signedFileName) = 0; +extern ADDAPI bool MONERO_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName); +extern ADDAPI const char* MONERO_UnsignedTransaction_signUR(void* unsignedTx_ptr, int max_fragment_length); +// }; +// struct TransactionInfo +// { +// enum Direction { +// Direction_In, +extern ADDAPI const int MONERO_TransactionInfoDirection_In; +// Direction_Out +extern ADDAPI const int MONERO_TransactionInfoDirection_Out; +// }; +// struct Transfer { +// Transfer(uint64_t _amount, const std::string &address); +// const uint64_t amount; +// const std::string address; +// }; +// virtual ~TransactionInfo() = 0; +// virtual int direction() const = 0; +extern ADDAPI int MONERO_TransactionInfo_direction(void* txInfo_ptr); +// virtual bool isPending() const = 0; +extern ADDAPI bool MONERO_TransactionInfo_isPending(void* txInfo_ptr); +// virtual bool isFailed() const = 0; +extern ADDAPI bool MONERO_TransactionInfo_isFailed(void* txInfo_ptr); +// virtual bool isCoinbase() const = 0; +extern ADDAPI bool MONERO_TransactionInfo_isCoinbase(void* txInfo_ptr); +// virtual uint64_t amount() const = 0; +extern ADDAPI uint64_t MONERO_TransactionInfo_amount(void* txInfo_ptr); +// virtual uint64_t fee() const = 0; +extern ADDAPI uint64_t MONERO_TransactionInfo_fee(void* txInfo_ptr); +// virtual uint64_t blockHeight() const = 0; +extern ADDAPI uint64_t MONERO_TransactionInfo_blockHeight(void* txInfo_ptr); +// virtual std::string description() const = 0; +extern ADDAPI const char* MONERO_TransactionInfo_description(void* txInfo_ptr); +// virtual std::set subaddrIndex() const = 0; +extern ADDAPI const char* MONERO_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator); +// virtual uint32_t subaddrAccount() const = 0; +extern ADDAPI uint32_t MONERO_TransactionInfo_subaddrAccount(void* txInfo_ptr); +// virtual std::string label() const = 0; +extern ADDAPI const char* MONERO_TransactionInfo_label(void* txInfo_ptr); +// virtual uint64_t confirmations() const = 0; +extern ADDAPI uint64_t MONERO_TransactionInfo_confirmations(void* txInfo_ptr); +// virtual uint64_t unlockTime() const = 0; +extern ADDAPI uint64_t MONERO_TransactionInfo_unlockTime(void* txInfo_ptr); +// virtual std::string hash() const = 0; +extern ADDAPI const char* MONERO_TransactionInfo_hash(void* txInfo_ptr); +// virtual std::time_t timestamp() const = 0; +extern ADDAPI uint64_t MONERO_TransactionInfo_timestamp(void* txInfo_ptr); +// virtual std::string paymentId() const = 0; +extern ADDAPI const char* MONERO_TransactionInfo_paymentId(void* txInfo_ptr); +// virtual const std::vector & transfers() const = 0; +extern ADDAPI int MONERO_TransactionInfo_transfers_count(void* txInfo_ptr); +extern ADDAPI uint64_t MONERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index); +extern ADDAPI const char* MONERO_TransactionInfo_transfers_address(void* txInfo_ptr, int address); +// }; +// struct TransactionHistory +// { +// virtual ~TransactionHistory() = 0; +// virtual int count() const = 0; +extern ADDAPI int MONERO_TransactionHistory_count(void* txHistory_ptr); +// virtual TransactionInfo * transaction(int index) const = 0; +extern ADDAPI void* MONERO_TransactionHistory_transaction(void* txHistory_ptr, int index); +// virtual TransactionInfo * transaction(const std::string &id) const = 0; +extern ADDAPI void* MONERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id); +// virtual std::vector getAll() const = 0; +// virtual void refresh() = 0; +extern ADDAPI void MONERO_TransactionHistory_refresh(void* txHistory_ptr); +// virtual void setTxNote(const std::string &txid, const std::string ¬e) = 0; +extern ADDAPI void MONERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note); +// }; +// struct AddressBookRow { +// public: +// AddressBookRow(std::size_t _rowId, const std::string &_address, const std::string &_paymentId, const std::string &_description): +// m_rowId(_rowId), +// m_address(_address), +// m_paymentId(_paymentId), +// m_description(_description) {} + +// private: +// std::size_t m_rowId; +// std::string m_address; +// std::string m_paymentId; +// std::string m_description; +// public: +// std::string extra; +extern ADDAPI const char* MONERO_AddressBookRow_extra(void* addressBookRow_ptr); +// std::string getAddress() const {return m_address;} +extern ADDAPI const char* MONERO_AddressBookRow_getAddress(void* addressBookRow_ptr); +// std::string getDescription() const {return m_description;} +extern ADDAPI const char* MONERO_AddressBookRow_getDescription(void* addressBookRow_ptr); +// std::string getPaymentId() const {return m_paymentId;} +extern ADDAPI const char* MONERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr); +// std::size_t getRowId() const {return m_rowId;} +extern ADDAPI size_t MONERO_AddressBookRow_getRowId(void* addressBookRow_ptr); +// }; +// struct AddressBook +// { +// enum ErrorCode { +// Status_Ok, +extern ADDAPI const int MONERO_AddressBookErrorCodeStatus_Ok; +// General_Error, +extern ADDAPI const int MONERO_AddressBookErrorCodeGeneral_Error; +// Invalid_Address, +extern ADDAPI const int MONERO_AddressBookErrorCodeInvalid_Address; +// Invalid_Payment_Id +extern ADDAPI const int MONERO_AddressBookErrorCodeInvalidPaymentId; +// }; +// virtual ~AddressBook() = 0; +// virtual std::vector getAll() const = 0; +extern ADDAPI int MONERO_AddressBook_getAll_size(void* addressBook_ptr); +extern ADDAPI void* MONERO_AddressBook_getAll_byIndex(void* addressBook_ptr, int index); +// virtual bool addRow(const std::string &dst_addr , const std::string &payment_id, const std::string &description) = 0; +extern ADDAPI bool MONERO_AddressBook_addRow(void* addressBook_ptr, const char* dst_addr , const char* payment_id, const char* description); +// virtual bool deleteRow(std::size_t rowId) = 0; +extern ADDAPI bool MONERO_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId); +// virtual bool setDescription(std::size_t index, const std::string &description) = 0; +extern ADDAPI bool MONERO_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description); +// virtual void refresh() = 0; +extern ADDAPI void MONERO_AddressBook_refresh(void* addressBook_ptr); +// virtual std::string errorString() const = 0; +extern ADDAPI const char* MONERO_AddressBook_errorString(void* addressBook_ptr); +// virtual int errorCode() const = 0; +extern ADDAPI int MONERO_AddressBook_errorCode(void* addressBook_ptr); +// virtual int lookupPaymentID(const std::string &payment_id) const = 0; +extern ADDAPI int MONERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id); +// }; +// struct CoinsInfo +// { +// virtual ~CoinsInfo() = 0; +// virtual uint64_t blockHeight() const = 0; +extern ADDAPI uint64_t MONERO_CoinsInfo_blockHeight(void* coinsInfo_ptr); +// virtual std::string hash() const = 0; +extern ADDAPI const char* MONERO_CoinsInfo_hash(void* coinsInfo_ptr); +// virtual size_t internalOutputIndex() const = 0; +extern ADDAPI size_t MONERO_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr); +// virtual uint64_t globalOutputIndex() const = 0; +extern ADDAPI uint64_t MONERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr); +// virtual bool spent() const = 0; +extern ADDAPI bool MONERO_CoinsInfo_spent(void* coinsInfo_ptr); +// virtual bool frozen() const = 0; +extern ADDAPI bool MONERO_CoinsInfo_frozen(void* coinsInfo_ptr); +// virtual uint64_t spentHeight() const = 0; +extern ADDAPI uint64_t MONERO_CoinsInfo_spentHeight(void* coinsInfo_ptr); +// virtual uint64_t amount() const = 0; +extern ADDAPI uint64_t MONERO_CoinsInfo_amount(void* coinsInfo_ptr); +// virtual bool rct() const = 0; +extern ADDAPI bool MONERO_CoinsInfo_rct(void* coinsInfo_ptr); +// virtual bool keyImageKnown() const = 0; +extern ADDAPI bool MONERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr); +// virtual size_t pkIndex() const = 0; +extern ADDAPI size_t MONERO_CoinsInfo_pkIndex(void* coinsInfo_ptr); +// virtual uint32_t subaddrIndex() const = 0; +extern ADDAPI uint32_t MONERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr); +// virtual uint32_t subaddrAccount() const = 0; +extern ADDAPI uint32_t MONERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr); +// virtual std::string address() const = 0; +extern ADDAPI const char* MONERO_CoinsInfo_address(void* coinsInfo_ptr); +// virtual std::string addressLabel() const = 0; +extern ADDAPI const char* MONERO_CoinsInfo_addressLabel(void* coinsInfo_ptr); +// virtual std::string keyImage() const = 0; +extern ADDAPI const char* MONERO_CoinsInfo_keyImage(void* coinsInfo_ptr); +// virtual uint64_t unlockTime() const = 0; +extern ADDAPI uint64_t MONERO_CoinsInfo_unlockTime(void* coinsInfo_ptr); +// virtual bool unlocked() const = 0; +extern ADDAPI bool MONERO_CoinsInfo_unlocked(void* coinsInfo_ptr); +// virtual std::string pubKey() const = 0; +extern ADDAPI const char* MONERO_CoinsInfo_pubKey(void* coinsInfo_ptr); +// virtual bool coinbase() const = 0; +extern ADDAPI bool MONERO_CoinsInfo_coinbase(void* coinsInfo_ptr); +// virtual std::string description() const = 0; +extern ADDAPI const char* MONERO_CoinsInfo_description(void* coinsInfo_ptr); +// }; +// struct Coins +// { +// virtual ~Coins() = 0; +// virtual int count() const = 0; +extern ADDAPI int MONERO_Coins_count(void* coins_ptr); +// virtual CoinsInfo * coin(int index) const = 0; +extern ADDAPI void* MONERO_Coins_coin(void* coins_ptr, int index); +// virtual std::vector getAll() const = 0; +extern ADDAPI int MONERO_Coins_getAll_size(void* coins_ptr); +extern ADDAPI void* MONERO_Coins_getAll_byIndex(void* coins_ptr, int index); +// virtual void refresh() = 0; +extern ADDAPI void MONERO_Coins_refresh(void* coins_ptr); +// virtual void setFrozen(std::string public_key) = 0; +extern ADDAPI void MONERO_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key); +// virtual void setFrozen(int index) = 0; +extern ADDAPI void MONERO_Coins_setFrozen(void* coins_ptr, int index); +// virtual void thaw(int index) = 0; +extern ADDAPI void MONERO_Coins_thaw(void* coins_ptr, int index); +// virtual void thaw(std::string public_key) = 0; +extern ADDAPI void MONERO_Coins_thawByPublicKey(void* coins_ptr, const char* public_key); +// virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0; +extern ADDAPI bool MONERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight); +// virtual void setDescription(const std::string &public_key, const std::string &description) = 0; +extern ADDAPI void MONERO_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description); +// }; +// struct SubaddressRow { +// public: +// SubaddressRow(std::size_t _rowId, const std::string &_address, const std::string &_label): +// m_rowId(_rowId), +// m_address(_address), +// m_label(_label) {} + +// private: +// std::size_t m_rowId; +// std::string m_address; +// std::string m_label; +// public: +// std::string extra; +extern ADDAPI const char* MONERO_SubaddressRow_extra(void* subaddressRow_ptr); +// std::string getAddress() const {return m_address;} +extern ADDAPI const char* MONERO_SubaddressRow_getAddress(void* subaddressRow_ptr); +// std::string getLabel() const {return m_label;} +extern ADDAPI const char* MONERO_SubaddressRow_getLabel(void* subaddressRow_ptr); +// std::size_t getRowId() const {return m_rowId;} +extern ADDAPI size_t MONERO_SubaddressRow_getRowId(void* subaddressRow_ptr); +// }; + +// struct Subaddress +// { +// virtual ~Subaddress() = 0; +// virtual std::vector getAll() const = 0; +extern ADDAPI int MONERO_Subaddress_getAll_size(void* subaddress_ptr); +extern ADDAPI void* MONERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index); +// virtual void addRow(uint32_t accountIndex, const std::string &label) = 0; +extern ADDAPI void MONERO_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label); +// virtual void setLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0; +extern ADDAPI void MONERO_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label); +// virtual void refresh(uint32_t accountIndex) = 0; +extern ADDAPI void MONERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex); +// }; + +// struct SubaddressAccountRow { +// public: +// SubaddressAccountRow(std::size_t _rowId, const std::string &_address, const std::string &_label, const std::string &_balance, const std::string &_unlockedBalance): +// m_rowId(_rowId), +// m_address(_address), +// m_label(_label), +// m_balance(_balance), +// m_unlockedBalance(_unlockedBalance) {} + +// private: +// std::size_t m_rowId; +// std::string m_address; +// std::string m_label; +// std::string m_balance; +// std::string m_unlockedBalance; +// public: +// std::string extra; +extern ADDAPI const char* MONERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr); +// std::string getAddress() const {return m_address;} +extern ADDAPI const char* MONERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr); +// std::string getLabel() const {return m_label;} +extern ADDAPI const char* MONERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr); +// std::string getBalance() const {return m_balance;} +extern ADDAPI const char* MONERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr); +// std::string getUnlockedBalance() const {return m_unlockedBalance;} +extern ADDAPI const char* MONERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr); +// std::size_t getRowId() const {return m_rowId;} +extern ADDAPI size_t MONERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr); +// }; + +// struct SubaddressAccount +// { +// virtual ~SubaddressAccount() = 0; +// virtual std::vector getAll() const = 0; +extern ADDAPI int MONERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr); +extern ADDAPI void* MONERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index); +// virtual void addRow(const std::string &label) = 0; +extern ADDAPI void MONERO_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label); +// virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0; +extern ADDAPI void MONERO_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label); +// virtual void refresh() = 0; +extern ADDAPI void MONERO_SubaddressAccount_refresh(void* subaddressAccount_ptr); +// }; + +// struct MultisigState { +// MultisigState() : isMultisig(false), isReady(false), threshold(0), total(0) {} + +// bool isMultisig; +extern ADDAPI bool MONERO_MultisigState_isMultisig(void* multisigState_ptr); +// bool isReady; +extern ADDAPI bool MONERO_MultisigState_isReady(void* multisigState_ptr); +// uint32_t threshold; +extern ADDAPI uint32_t MONERO_MultisigState_threshold(void* multisigState_ptr); +// uint32_t total; +extern ADDAPI uint32_t MONERO_MultisigState_total(void* multisigState_ptr); +// }; + + +// struct DeviceProgress { +// DeviceProgress(): m_progress(0), m_indeterminate(false) {} +// DeviceProgress(double progress, bool indeterminate=false): m_progress(progress), m_indeterminate(indeterminate) {} + +// virtual double progress() const { return m_progress; } +extern ADDAPI bool MONERO_DeviceProgress_progress(void* deviceProgress_ptr); +// virtual bool indeterminate() const { return m_indeterminate; } +extern ADDAPI bool MONERO_DeviceProgress_indeterminate(void* deviceProgress_ptr); + +// protected: +// double m_progress; +// bool m_indeterminate; +// }; + +// struct Wallet; +// struct WalletListener +// { +// virtual ~WalletListener() = 0; +// virtual void moneySpent(const std::string &txId, uint64_t amount) = 0; +// virtual void moneyReceived(const std::string &txId, uint64_t amount) = 0; +// virtual void unconfirmedMoneyReceived(const std::string &txId, uint64_t amount) = 0; +// virtual void newBlock(uint64_t height) = 0; +// virtual void updated() = 0; +// virtual void refreshed() = 0; +// virtual void onDeviceButtonRequest(uint64_t code) { (void)code; } +// virtual void onDeviceButtonPressed() { } +// virtual optional onDevicePinRequest() { +// throw std::runtime_error("Not supported"); +// } +// virtual optional onDevicePassphraseRequest(bool & on_device) { +// on_device = true; +// return optional(); +// } +// virtual void onDeviceProgress(const DeviceProgress & event) { (void)event; }; +// virtual void onSetWallet(Wallet * wallet) { (void)wallet; }; +// }; +// struct Wallet +// { +// enum Device { +// Device_Software = 0, +extern ADDAPI const int MONERO_WalletDevice_Software; +// Device_Ledger = 1, +extern ADDAPI const int MONERO_WalletDevice_Ledger; +// Device_Trezor = 2 +extern ADDAPI const int MONERO_WalletDevice_Trezor; +// }; +// enum Status { +// Status_Ok, +extern ADDAPI const int MONERO_WalletStatus_Ok; +// Status_Error, +extern ADDAPI const int MONERO_WalletStatus_Error; +// Status_Critical +extern ADDAPI const int MONERO_WalletStatus_Critical; +// }; +// enum ConnectionStatus { +// ConnectionStatus_Disconnected, +extern ADDAPI const int MONERO_WalletConnectionStatus_Disconnected; +// ConnectionStatus_Connected, +extern ADDAPI const int MONERO_WalletConnectionStatus_Connected; +// ConnectionStatus_WrongVersion +extern ADDAPI const int MONERO_WalletConnectionStatus_WrongVersion; +// }; +// enum BackgroundSyncType { +// BackgroundSync_Off = 0, +extern ADDAPI const int MONERO_WalletBackgroundSync_Off; +// BackgroundSync_ReusePassword = 1, +extern ADDAPI const int MONERO_WalletBackgroundSync_ReusePassword; +// BackgroundSync_CustomPassword = 2 +extern ADDAPI const int MONERO_WalletBackgroundSync_CustomPassword; +// }; +// virtual ~Wallet() = 0; +// virtual std::string seed(const std::string& seed_offset = "") const = 0; +extern ADDAPI const char* MONERO_Wallet_seed(void* wallet_ptr, const char* seed_offset); +// virtual std::string getSeedLanguage() const = 0; +extern ADDAPI const char* MONERO_Wallet_getSeedLanguage(void* wallet_ptr); +// virtual void setSeedLanguage(const std::string &arg) = 0; +extern ADDAPI void MONERO_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg); +// virtual int status() const = 0; +extern ADDAPI int MONERO_Wallet_status(void* wallet_ptr); +// virtual std::string errorString() const = 0; +extern ADDAPI const char* MONERO_Wallet_errorString(void* wallet_ptr); +// virtual void statusWithErrorString(int& status, std::string& errorString) const = 0; +// virtual bool setPassword(const std::string &password) = 0; +extern ADDAPI bool MONERO_Wallet_setPassword(void* wallet_ptr, const char* password); +// virtual const std::string& getPassword() const = 0; +extern ADDAPI const char* MONERO_Wallet_getPassword(void* wallet_ptr); +// virtual bool setDevicePin(const std::string &pin) { (void)pin; return false; }; +extern ADDAPI bool MONERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin); +// virtual bool setDevicePassphrase(const std::string &passphrase) { (void)passphrase; return false; }; +extern ADDAPI bool MONERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase); +// virtual std::string address(uint32_t accountIndex = 0, uint32_t addressIndex = 0) const = 0; +extern ADDAPI const char* MONERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex); +// std::string mainAddress() const { return address(0, 0); } +// virtual std::string path() const = 0; +extern ADDAPI const char* MONERO_Wallet_path(void* wallet_ptr); +// virtual NetworkType nettype() const = 0; +extern ADDAPI int MONERO_Wallet_nettype(void* wallet_ptr); +// bool mainnet() const { return nettype() == MAINNET; } +// bool testnet() const { return nettype() == TESTNET; } +// bool stagenet() const { return nettype() == STAGENET; } +// virtual void hardForkInfo(uint8_t &version, uint64_t &earliest_height) const = 0; +// virtual bool useForkRules(uint8_t version, int64_t early_blocks) const = 0; +extern ADDAPI uint8_t MONERO_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks); +// virtual std::string integratedAddress(const std::string &payment_id) const = 0; +extern ADDAPI const char* MONERO_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id); +// virtual std::string secretViewKey() const = 0; +extern ADDAPI const char* MONERO_Wallet_secretViewKey(void* wallet_ptr); +// virtual std::string publicViewKey() const = 0; +extern ADDAPI const char* MONERO_Wallet_publicViewKey(void* wallet_ptr); +// virtual std::string secretSpendKey() const = 0; +extern ADDAPI const char* MONERO_Wallet_secretSpendKey(void* wallet_ptr); +// virtual std::string publicSpendKey() const = 0; +extern ADDAPI const char* MONERO_Wallet_publicSpendKey(void* wallet_ptr); +// virtual std::string publicMultisigSignerKey() const = 0; +extern ADDAPI const char* MONERO_Wallet_publicMultisigSignerKey(void* wallet_ptr); +// virtual void stop() = 0; +extern ADDAPI void MONERO_Wallet_stop(void* wallet_ptr); +// virtual bool store(const std::string &path) = 0; +extern ADDAPI bool MONERO_Wallet_store(void* wallet_ptr, const char* path); +// virtual std::string filename() const = 0; +extern ADDAPI const char* MONERO_Wallet_filename(void* wallet_ptr); +// virtual std::string keysFilename() const = 0; +extern ADDAPI const char* MONERO_Wallet_keysFilename(void* wallet_ptr); +// virtual bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit = 0, const std::string &daemon_username = "", const std::string &daemon_password = "", bool use_ssl = false, bool lightWallet = false, const std::string &proxy_address = "") = 0; +extern ADDAPI bool MONERO_Wallet_init(void* wallet_ptr, const char* daemon_address, uint64_t upper_transaction_size_limit, const char* daemon_username, const char* daemon_password, bool use_ssl, bool lightWallet, const char* proxy_address); +// virtual bool createWatchOnly(const std::string &path, const std::string &password, const std::string &language) const = 0; +extern ADDAPI bool MONERO_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language); +// virtual void setRefreshFromBlockHeight(uint64_t refresh_from_block_height) = 0; +extern ADDAPI void MONERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height); +// virtual uint64_t getRefreshFromBlockHeight() const = 0; +extern ADDAPI uint64_t MONERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr); +// virtual void setRecoveringFromSeed(bool recoveringFromSeed) = 0; +extern ADDAPI void MONERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed); +// virtual void setRecoveringFromDevice(bool recoveringFromDevice) = 0; +extern ADDAPI void MONERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice); +// virtual void setSubaddressLookahead(uint32_t major, uint32_t minor) = 0; +extern ADDAPI void MONERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor); +// virtual bool connectToDaemon() = 0; +extern ADDAPI bool MONERO_Wallet_connectToDaemon(void* wallet_ptr); +// virtual ConnectionStatus connected() const = 0; +extern ADDAPI int MONERO_Wallet_connected(void* wallet_ptr); +// virtual void setTrustedDaemon(bool arg) = 0; +extern ADDAPI void MONERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg); +// virtual bool trustedDaemon() const = 0; +extern ADDAPI bool MONERO_Wallet_trustedDaemon(void* wallet_ptr); +// virtual bool setProxy(const std::string &address) = 0; +extern ADDAPI bool MONERO_Wallet_setProxy(void* wallet_ptr, const char* address); +// virtual uint64_t balance(uint32_t accountIndex = 0) const = 0; +extern ADDAPI uint64_t MONERO_Wallet_balance(void* wallet_ptr, uint32_t accountIndex); +// uint64_t balanceAll() const { +// uint64_t result = 0; +// for (uint32_t i = 0; i < numSubaddressAccounts(); ++i) +// result += balance(i); +// return result; +// } +// virtual uint64_t unlockedBalance(uint32_t accountIndex = 0) const = 0; +extern ADDAPI uint64_t MONERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex); +// uint64_t unlockedBalanceAll() const { +// uint64_t result = 0; +// for (uint32_t i = 0; i < numSubaddressAccounts(); ++i) +// result += unlockedBalance(i); +// return result; +// } +// virtual bool watchOnly() const = 0; +// virtual uint64_t viewOnlyBalance(uint32_t accountIndex, const std::vector &key_images = {}) const = 0; +extern ADDAPI uint64_t MONERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex); +extern ADDAPI bool MONERO_Wallet_watchOnly(void* wallet_ptr); +// virtual bool isDeterministic() const = 0; +extern ADDAPI bool MONERO_Wallet_isDeterministic(void* wallet_ptr); +// virtual uint64_t blockChainHeight() const = 0; +extern ADDAPI uint64_t MONERO_Wallet_blockChainHeight(void* wallet_ptr); +// virtual uint64_t approximateBlockChainHeight() const = 0; +extern ADDAPI uint64_t MONERO_Wallet_approximateBlockChainHeight(void* wallet_ptr); +// virtual uint64_t estimateBlockChainHeight() const = 0; +extern ADDAPI uint64_t MONERO_Wallet_estimateBlockChainHeight(void* wallet_ptr); +// virtual uint64_t daemonBlockChainHeight() const = 0; +extern ADDAPI uint64_t MONERO_Wallet_daemonBlockChainHeight(void* wallet_ptr); +// virtual uint64_t daemonBlockChainTargetHeight() const = 0; +extern ADDAPI uint64_t MONERO_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr); +// virtual bool synchronized() const = 0; +extern ADDAPI bool MONERO_Wallet_synchronized(void* wallet_ptr); +// static std::string displayAmount(uint64_t amount); +extern ADDAPI const char* MONERO_Wallet_displayAmount(uint64_t amount); +// static uint64_t amountFromString(const std::string &amount); +extern ADDAPI uint64_t MONERO_Wallet_amountFromString(const char* amount); +// static uint64_t amountFromDouble(double amount); +extern ADDAPI uint64_t MONERO_Wallet_amountFromDouble(double amount); +// static std::string genPaymentId(); +extern ADDAPI const char* MONERO_Wallet_genPaymentId(); +// static bool paymentIdValid(const std::string &paiment_id); +extern ADDAPI bool MONERO_Wallet_paymentIdValid(const char* paiment_id); +// static bool addressValid(const std::string &str, NetworkType nettype); +extern ADDAPI bool MONERO_Wallet_addressValid(const char* str, int nettype); +// static bool addressValid(const std::string &str, bool testnet) // deprecated +// { +// return addressValid(str, testnet ? TESTNET : MAINNET); +// } +extern ADDAPI bool MONERO_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype); +extern ADDAPI const char* MONERO_Wallet_keyValid_error(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype); +// static bool keyValid(const std::string &secret_key_string, const std::string &address_string, bool isViewKey, NetworkType nettype, std::string &error); +// static bool keyValid(const std::string &secret_key_string, const std::string &address_string, bool isViewKey, bool testnet, std::string &error) // deprecated +// { +// return keyValid(secret_key_string, address_string, isViewKey, testnet ? TESTNET : MAINNET, error); +// } +// static std::string paymentIdFromAddress(const std::string &str, NetworkType nettype); +extern ADDAPI const char* MONERO_Wallet_paymentIdFromAddress(const char* strarg, int nettype); +// static std::string paymentIdFromAddress(const std::string &str, bool testnet) // deprecated +// { +// return paymentIdFromAddress(str, testnet ? TESTNET : MAINNET); +// } +// static uint64_t maximumAllowedAmount(); +extern ADDAPI uint64_t MONERO_Wallet_maximumAllowedAmount(); +// static void init(const char *argv0, const char *default_log_base_name) { init(argv0, default_log_base_name, "", true); } +// static void init(const char *argv0, const char *default_log_base_name, const std::string &log_path, bool console); +extern ADDAPI void MONERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console); +// static void debug(const std::string &category, const std::string &str); +// static void info(const std::string &category, const std::string &str); +// static void warning(const std::string &category, const std::string &str); +// static void error(const std::string &category, const std::string &str); +// virtual void startRefresh() = 0; +// virtual bool getPolyseed(std::string &seed, std::string &passphrase) const = 0; +extern ADDAPI const char* MONERO_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase); +// static bool createPolyseed(std::string &seed_words, std::string &err, const std::string &language = "English"); +extern ADDAPI const char* MONERO_Wallet_createPolyseed(const char* language); +extern ADDAPI void MONERO_Wallet_startRefresh(void* wallet_ptr); +// virtual void pauseRefresh() = 0; +extern ADDAPI void MONERO_Wallet_pauseRefresh(void* wallet_ptr); +// virtual bool refresh() = 0; +extern ADDAPI bool MONERO_Wallet_refresh(void* wallet_ptr); +// virtual void refreshAsync() = 0; +extern ADDAPI void MONERO_Wallet_refreshAsync(void* wallet_ptr); +// virtual bool rescanBlockchain() = 0; +extern ADDAPI bool MONERO_Wallet_rescanBlockchain(void* wallet_ptr); +// virtual void rescanBlockchainAsync() = 0; +extern ADDAPI void MONERO_Wallet_rescanBlockchainAsync(void* wallet_ptr); +// virtual void setAutoRefreshInterval(int millis) = 0; +extern ADDAPI void MONERO_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis); +// virtual int autoRefreshInterval() const = 0; +extern ADDAPI int MONERO_Wallet_autoRefreshInterval(void* wallet_ptr); +// virtual void addSubaddressAccount(const std::string& label) = 0; +extern ADDAPI void MONERO_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label); +// virtual size_t numSubaddressAccounts() const = 0; +extern ADDAPI size_t MONERO_Wallet_numSubaddressAccounts(void* wallet_ptr); +// virtual size_t numSubaddresses(uint32_t accountIndex) const = 0; +extern ADDAPI size_t MONERO_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex); +// virtual void addSubaddress(uint32_t accountIndex, const std::string& label) = 0; +extern ADDAPI void MONERO_Wallet_addSubaddress(void* wallet_ptr, uint32_t accountIndex, const char* label); +// virtual std::string getSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex) const = 0; +extern ADDAPI const char* MONERO_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex); +// virtual void setSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0; +extern ADDAPI void MONERO_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label); +// virtual MultisigState multisig() const = 0; +extern ADDAPI void* MONERO_Wallet_multisig(void* wallet_ptr); +// virtual std::string getMultisigInfo() const = 0; +extern ADDAPI const char* MONERO_Wallet_getMultisigInfo(void* wallet_ptr); +// virtual std::string makeMultisig(const std::vector& info, uint32_t threshold) = 0; +extern ADDAPI const char* MONERO_Wallet_makeMultisig(void* wallet_ptr, const char* info, const char* info_separator, uint32_t threshold); +// virtual std::string exchangeMultisigKeys(const std::vector &info, const bool force_update_use_with_caution) = 0; +extern ADDAPI const char* MONERO_Wallet_exchangeMultisigKeys(void* wallet_ptr, const char* info, const char* info_separator, bool force_update_use_with_caution); +// virtual bool exportMultisigImages(std::string& images) = 0; +extern ADDAPI const char* MONERO_Wallet_exportMultisigImages(void* wallet_ptr, const char* separator); +// virtual size_t importMultisigImages(const std::vector& images) = 0; +extern ADDAPI size_t MONERO_Wallet_importMultisigImages(void* wallet_ptr, const char* info, const char* info_separator); +// virtual bool hasMultisigPartialKeyImages() const = 0; +extern ADDAPI size_t MONERO_Wallet_hasMultisigPartialKeyImages(void* wallet_ptr); +// virtual PendingTransaction* restoreMultisigTransaction(const std::string& signData) = 0; +extern ADDAPI void* MONERO_Wallet_restoreMultisigTransaction(void* wallet_ptr, const char* signData); +// virtual PendingTransaction * createTransactionMultDest(const std::vector &dst_addr, const std::string &payment_id, +// optional> amount, uint32_t mixin_count, +// PendingTransaction::Priority = PendingTransaction::Priority_Low, +// uint32_t subaddr_account = 0, +// std::set subaddr_indices = {}) = 0; +extern ADDAPI void* MONERO_Wallet_createTransactionMultDest(void* wallet_ptr, const char* dst_addr_list, const char* dst_addr_list_separator, const char* payment_id, + bool amount_sweep_all, const char* amount_list, const char* amount_list_separator, uint32_t mixin_count, + int pendingTransactionPriority, + uint32_t subaddr_account, + const char* preferredInputs, const char* preferredInputs_separator); +// virtual PendingTransaction * createTransaction(const std::string &dst_addr, const std::string &payment_id, +// optional amount, uint32_t mixin_count, +// PendingTransaction::Priority = PendingTransaction::Priority_Low, +// uint32_t subaddr_account = 0, +// std::set subaddr_indices = {}, +// const std::set &preferred_inputs = {) = 0; +extern ADDAPI void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, + uint64_t amount, uint32_t mixin_count, + int pendingTransactionPriority, + uint32_t subaddr_account, + const char* preferredInputs, const char* separator); +// virtual PendingTransaction * createSweepUnmixableTransaction() = 0; +// virtual UnsignedTransaction * loadUnsignedTx(const std::string &unsigned_filename) = 0; +extern ADDAPI void* MONERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* unsigned_filename); +extern ADDAPI void* MONERO_Wallet_loadUnsignedTxUR(void* wallet_ptr, const char* input); +// virtual bool submitTransaction(const std::string &fileName) = 0; +extern ADDAPI bool MONERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName); +extern ADDAPI bool MONERO_Wallet_submitTransactionUR(void* wallet_ptr, const char* input); +// virtual void disposeTransaction(PendingTransaction * t) = 0; +// virtual uint64_t estimateTransactionFee(const std::vector> &destinations, +// PendingTransaction::Priority priority) const = 0; +// virtual bool hasUnknownKeyImages() const = 0; +extern ADDAPI bool MONERO_Wallet_hasUnknownKeyImages(void* wallet_ptr); +// virtual bool exportKeyImages(const std::string &filename, bool all = false) = 0; +extern ADDAPI bool MONERO_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all); +extern ADDAPI const char* MONERO_Wallet_exportKeyImagesUR(void* wallet_ptr, size_t max_fragment_length, bool all) ; +// virtual bool importKeyImages(const std::string &filename) = 0; +extern ADDAPI bool MONERO_Wallet_importKeyImages(void* wallet_ptr, const char* filename); +extern ADDAPI bool MONERO_Wallet_importKeyImagesUR(void* wallet_ptr, const char* input); +// virtual bool exportOutputs(const std::string &filename, bool all = false) = 0; +extern ADDAPI bool MONERO_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool all); +extern ADDAPI const char* MONERO_Wallet_exportOutputsUR(void* wallet_ptr, size_t max_fragment_length, bool all); +// virtual bool importOutputs(const std::string &filename) = 0; +extern ADDAPI bool MONERO_Wallet_importOutputs(void* wallet_ptr, const char* filename); +extern ADDAPI bool MONERO_Wallet_importOutputsUR(void* wallet_ptr, const char* input); +// virtual bool scanTransactions(const std::vector &txids) = 0; +// virtual bool setupBackgroundSync(const BackgroundSyncType background_sync_type, const std::string &wallet_password, const optional &background_cache_password) = 0; +extern ADDAPI bool MONERO_Wallet_setupBackgroundSync(void* wallet_ptr, int background_sync_type, const char* wallet_password, const char* background_cache_password); +// virtual BackgroundSyncType getBackgroundSyncType() const = 0; +extern ADDAPI int MONERO_Wallet_getBackgroundSyncType(void* wallet_ptr); +// virtual bool startBackgroundSync() = 0; +extern ADDAPI bool MONERO_Wallet_startBackgroundSync(void* wallet_ptr); +// virtual bool stopBackgroundSync(const std::string &wallet_password) = 0; +extern ADDAPI bool MONERO_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password); +// virtual bool isBackgroundSyncing() const = 0; +extern ADDAPI bool MONERO_Wallet_isBackgroundSyncing(void* wallet_ptr); +// virtual bool isBackgroundWallet() const = 0; +extern ADDAPI bool MONERO_Wallet_isBackgroundWallet(void* wallet_ptr); +// virtual TransactionHistory * history() = 0; +extern ADDAPI void* MONERO_Wallet_history(void* wallet_ptr); +// virtual AddressBook * addressBook() = 0; +extern ADDAPI void* MONERO_Wallet_addressBook(void* wallet_ptr); +// virtual Coins * coins() = 0; +extern ADDAPI void* MONERO_Wallet_coins(void* wallet_ptr); +// virtual Subaddress * subaddress() = 0; +extern ADDAPI void* MONERO_Wallet_subaddress(void* wallet_ptr); +// virtual SubaddressAccount * subaddressAccount() = 0; +extern ADDAPI void* MONERO_Wallet_subaddressAccount(void* wallet_ptr); +// virtual void setListener(WalletListener *) = 0; +// virtual uint32_t defaultMixin() const = 0; +extern ADDAPI uint32_t MONERO_Wallet_defaultMixin(void* wallet_ptr); +// virtual void setDefaultMixin(uint32_t arg) = 0; +extern ADDAPI void MONERO_Wallet_setDefaultMixin(void* wallet_ptr, uint32_t arg); +// virtual bool setCacheAttribute(const std::string &key, const std::string &val) = 0; +extern ADDAPI bool MONERO_Wallet_setCacheAttribute(void* wallet_ptr, const char* key, const char* val); +// virtual std::string getCacheAttribute(const std::string &key) const = 0; +extern ADDAPI const char* MONERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key); +// virtual bool setUserNote(const std::string &txid, const std::string ¬e) = 0; +extern ADDAPI bool MONERO_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note); +// virtual std::string getUserNote(const std::string &txid) const = 0; +extern ADDAPI const char* MONERO_Wallet_getUserNote(void* wallet_ptr, const char* txid); +// virtual std::string getTxKey(const std::string &txid) const = 0; +extern ADDAPI const char* MONERO_Wallet_getTxKey(void* wallet_ptr, const char* txid); +// virtual bool checkTxKey(const std::string &txid, std::string tx_key, const std::string &address, uint64_t &received, bool &in_pool, uint64_t &confirmations) = 0; +// virtual std::string getTxProof(const std::string &txid, const std::string &address, const std::string &message) const = 0; +// virtual bool checkTxProof(const std::string &txid, const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &received, bool &in_pool, uint64_t &confirmations) = 0; +// virtual std::string getSpendProof(const std::string &txid, const std::string &message) const = 0; +// virtual bool checkSpendProof(const std::string &txid, const std::string &message, const std::string &signature, bool &good) const = 0; +// virtual std::string getReserveProof(bool all, uint32_t account_index, uint64_t amount, const std::string &message) const = 0; +// virtual bool checkReserveProof(const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &total, uint64_t &spent) const = 0; +// virtual std::string signMessage(const std::string &message, const std::string &address = "") = 0; +extern ADDAPI const char* MONERO_Wallet_signMessage(void* wallet_ptr, const char* message, const char* address); +// virtual bool verifySignedMessage(const std::string &message, const std::string &addres, const std::string &signature) const = 0; +extern ADDAPI bool MONERO_Wallet_verifySignedMessage(void* wallet_ptr, const char* message, const char* address, const char* signature); +// virtual std::string signMultisigParticipant(const std::string &message) const = 0; +// virtual bool verifyMessageWithPublicKey(const std::string &message, const std::string &publicKey, const std::string &signature) const = 0; +// virtual bool parse_uri(const std::string &uri, std::string &address, std::string &payment_id, uint64_t &amount, std::string &tx_description, std::string &recipient_name, std::vector &unknown_parameters, std::string &error) = 0; +// virtual std::string make_uri(const std::string &address, const std::string &payment_id, uint64_t amount, const std::string &tx_description, const std::string &recipient_name, std::string &error) const = 0; +// virtual std::string getDefaultDataDir() const = 0; +// virtual bool rescanSpent() = 0; +extern ADDAPI bool MONERO_Wallet_rescanSpent(void* wallet_ptr); +// virtual void setOffline(bool offline) = 0; +extern ADDAPI void MONERO_Wallet_setOffline(void* wallet_ptr, bool offline); +// virtual bool isOffline() const = 0; +extern ADDAPI bool MONERO_Wallet_isOffline(void* wallet_ptr); +// virtual bool blackballOutputs(const std::vector &outputs, bool add) = 0; +// virtual bool blackballOutput(const std::string &amount, const std::string &offset) = 0; +// virtual bool unblackballOutput(const std::string &amount, const std::string &offset) = 0; +// virtual bool getRing(const std::string &key_image, std::vector &ring) const = 0; +// virtual bool getRings(const std::string &txid, std::vector>> &rings) const = 0; +// virtual bool setRing(const std::string &key_image, const std::vector &ring, bool relative) = 0; +// virtual void segregatePreForkOutputs(bool segregate) = 0; +extern ADDAPI void MONERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate); +// virtual void segregationHeight(uint64_t height) = 0; +extern ADDAPI void MONERO_Wallet_segregationHeight(void* wallet_ptr, uint64_t height); +// virtual void keyReuseMitigation2(bool mitigation) = 0; +extern ADDAPI void MONERO_Wallet_keyReuseMitigation2(void* wallet_ptr, bool mitigation); +// virtual bool lightWalletLogin(bool &isNewWallet) const = 0; +// virtual bool lightWalletImportWalletRequest(std::string &payment_id, uint64_t &fee, bool &new_request, bool &request_fulfilled, std::string &payment_address, std::string &status) = 0; +// virtual bool lockKeysFile() = 0; +extern ADDAPI bool MONERO_Wallet_lockKeysFile(void* wallet_ptr); +// virtual bool unlockKeysFile() = 0; +extern ADDAPI bool MONERO_Wallet_unlockKeysFile(void* wallet_ptr); +// virtual bool isKeysFileLocked() = 0; +extern ADDAPI bool MONERO_Wallet_isKeysFileLocked(void* wallet_ptr); +// virtual Device getDeviceType() const = 0; +extern ADDAPI int MONERO_Wallet_getDeviceType(void* wallet_ptr); +// virtual uint64_t coldKeyImageSync(uint64_t &spent, uint64_t &unspent) = 0; +extern ADDAPI uint64_t MONERO_Wallet_coldKeyImageSync(void* wallet_ptr, uint64_t spent, uint64_t unspent); +// virtual void deviceShowAddress(uint32_t accountIndex, uint32_t addressIndex, const std::string &paymentId) = 0; +extern ADDAPI const char* MONERO_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex); +// virtual bool reconnectDevice() = 0; +extern ADDAPI bool MONERO_Wallet_reconnectDevice(void* wallet_ptr); +// virtual uint64_t getBytesReceived() = 0; +extern ADDAPI uint64_t MONERO_Wallet_getBytesReceived(void* wallet_ptr); +// virtual uint64_t getBytesSent() = 0; +extern ADDAPI uint64_t MONERO_Wallet_getBytesSent(void* wallet_ptr); + // HIDAPI_DUMMY +extern ADDAPI bool MONERO_Wallet_getStateIsConnected(); +extern ADDAPI unsigned char* MONERO_Wallet_getSendToDevice(); +extern ADDAPI size_t MONERO_Wallet_getSendToDeviceLength(); +extern ADDAPI unsigned char* MONERO_Wallet_getReceivedFromDevice(); +extern ADDAPI size_t MONERO_Wallet_getReceivedFromDeviceLength(); +extern ADDAPI bool MONERO_Wallet_getWaitsForDeviceSend(); +extern ADDAPI bool MONERO_Wallet_getWaitsForDeviceReceive(); +extern ADDAPI void MONERO_Wallet_setDeviceReceivedData(unsigned char* data, size_t len); +extern ADDAPI void MONERO_Wallet_setDeviceSendData(unsigned char* data, size_t len); +extern ADDAPI void MONERO_Wallet_setLedgerCallback(void (*sendToLedgerDevice)(unsigned char *command, unsigned int cmd_len)); +extern ADDAPI const char* MONERO_Wallet_serializeCacheToJson(void* wallet_ptr); +// }; + +// struct WalletManager +// { +// virtual Wallet * createWallet(const std::string &path, const std::string &password, const std::string &language, NetworkType nettype, uint64_t kdf_rounds = 1) = 0; +extern ADDAPI void* MONERO_WalletManager_createWallet(void* wm_ptr, const char* path, const char* password, const char* language, int networkType); +// Wallet * createWallet(const std::string &path, const std::string &password, const std::string &language, bool testnet = false) // deprecated +// { +// return createWallet(path, password, language, testnet ? TESTNET : MAINNET); +// } +// virtual Wallet * openWallet(const std::string &path, const std::string &password, NetworkType nettype, uint64_t kdf_rounds = 1, WalletListener * listener = nullptr) = 0; +extern ADDAPI void* MONERO_WalletManager_openWallet(void* wm_ptr, const char* path, const char* password, int networkType); +// Wallet * openWallet(const std::string &path, const std::string &password, bool testnet = false) // deprecated +// { +// return openWallet(path, password, testnet ? TESTNET : MAINNET); +// } +// virtual Wallet * recoveryWallet(const std::string &path, const std::string &password, const std::string &mnemonic, +// NetworkType nettype = MAINNET, uint64_t restoreHeight = 0, uint64_t kdf_rounds = 1, +// const std::string &seed_offset = {}) = 0; +extern ADDAPI void* MONERO_WalletManager_recoveryWallet(void* wm_ptr, const char* path, const char* password, const char* mnemonic, int networkType, uint64_t restoreHeight, uint64_t kdfRounds, const char* seedOffset); +// Wallet * recoveryWallet(const std::string &path, const std::string &password, const std::string &mnemonic, +// bool testnet = false, uint64_t restoreHeight = 0) // deprecated +// { +// return recoveryWallet(path, password, mnemonic, testnet ? TESTNET : MAINNET, restoreHeight); +// } +// virtual Wallet * recoveryWallet(const std::string &path, const std::string &mnemonic, NetworkType nettype, uint64_t restoreHeight = 0) = 0; +// Wallet * recoveryWallet(const std::string &path, const std::string &mnemonic, bool testnet = false, uint64_t restoreHeight = 0) // deprecated +// { +// return recoveryWallet(path, mnemonic, testnet ? TESTNET : MAINNET, restoreHeight); +// } +// virtual Wallet * createWalletFromKeys(const std::string &path, +// const std::string &password, +// const std::string &language, +// NetworkType nettype, +// uint64_t restoreHeight, +// const std::string &addressString, +// const std::string &viewKeyString, +// const std::string &spendKeyString = "", +// uint64_t kdf_rounds = 1) = 0; +extern ADDAPI void* MONERO_WalletManager_createWalletFromKeys(void* wm_ptr, const char* path, const char* password, const char* language, int nettype, uint64_t restoreHeight, const char* addressString, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds); +// Wallet * createWalletFromKeys(const std::string &path, +// const std::string &password, +// const std::string &language, +// bool testnet, +// uint64_t restoreHeight, +// const std::string &addressString, +// const std::string &viewKeyString, +// const std::string &spendKeyString = "") // deprecated +// { +// return createWalletFromKeys(path, password, language, testnet ? TESTNET : MAINNET, restoreHeight, addressString, viewKeyString, spendKeyString); +// } +// virtual Wallet * createWalletFromKeys(const std::string &path, +// const std::string &language, +// NetworkType nettype, +// uint64_t restoreHeight, +// const std::string &addressString, +// const std::string &viewKeyString, +// const std::string &spendKeyString = "") = 0; +// Wallet * createWalletFromKeys(const std::string &path, +// const std::string &language, +// bool testnet, +// uint64_t restoreHeight, +// const std::string &addressString, +// const std::string &viewKeyString, +// const std::string &spendKeyString = "") // deprecated +// { +// return createWalletFromKeys(path, language, testnet ? TESTNET : MAINNET, restoreHeight, addressString, viewKeyString, spendKeyString); +// } +// virtual Wallet * createDeterministicWalletFromSpendKey(const std::string &path, +// const std::string &password, +// const std::string &language, +// NetworkType nettype, +// uint64_t restoreHeight, +// const std::string &spendKeyString, +// uint64_t kdf_rounds = 1) = 0; +extern ADDAPI void* MONERO_WalletManager_createDeterministicWalletFromSpendKey(void* wm_ptr, const char* path, const char* password, + const char* language, int nettype, uint64_t restoreHeight, + const char* spendKeyString, uint64_t kdf_rounds); +// virtual Wallet * createWalletFromDevice(const std::string &path, +// const std::string &password, +// NetworkType nettype, +// const std::string &deviceName, +// uint64_t restoreHeight = 0, +// const std::string &subaddressLookahead = "", +// uint64_t kdf_rounds = 1, +// WalletListener * listener = nullptr) = 0; +extern ADDAPI void* MONERO_WalletManager_createWalletFromDevice(void* wm_ptr, const char* path, const char* password, int nettype, const char* deviceName, uint64_t restoreHeight, const char* subaddressLookahead, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds); +// virtual Wallet * createWalletFromPolyseed(const std::string &path, +// const std::string &password, +// NetworkType nettype, +// const std::string &mnemonic, +// const std::string &passphrase = "", +// bool newWallet = true, +// uint64_t restore_height = 0, +// uint64_t kdf_rounds = 1) = 0; +extern ADDAPI void* MONERO_WalletManager_createWalletFromPolyseed(void* wm_ptr, const char* path, const char* password, + int nettype, const char* mnemonic, const char* passphrase, + bool newWallet, uint64_t restore_height, uint64_t kdf_rounds); +// virtual bool closeWallet(Wallet *wallet, bool store = true) = 0; +extern ADDAPI bool MONERO_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store); +// virtual bool walletExists(const std::string &path) = 0; +extern ADDAPI bool MONERO_WalletManager_walletExists(void* wm_ptr, const char* path); +// virtual bool verifyWalletPassword(const std::string &keys_file_name, const std::string &password, bool no_spend_key, uint64_t kdf_rounds = 1) const = 0; +extern ADDAPI bool MONERO_WalletManager_verifyWalletPassword(void* wm_ptr, const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds); +// virtual bool queryWalletDevice(Wallet::Device& device_type, const std::string &keys_file_name, const std::string &password, uint64_t kdf_rounds = 1) const = 0; +extern ADDAPI int MONERO_WalletManager_queryWalletDevice(void* wm_ptr, const char* keys_file_name, const char* password, uint64_t kdf_rounds); +// virtual std::vector findWallets(const std::string &path) = 0; +extern ADDAPI const char* MONERO_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator); +// virtual std::string errorString() const = 0; +extern ADDAPI const char* MONERO_WalletManager_errorString(void* wm_ptr); +// virtual void setDaemonAddress(const std::string &address) = 0; +extern ADDAPI void MONERO_WalletManager_setDaemonAddress(void* wm_ptr, const char* address); +// virtual bool connected(uint32_t *version = NULL) = 0; +// virtual uint64_t blockchainHeight() = 0; +extern ADDAPI uint64_t MONERO_WalletManager_blockchainHeight(void* wm_ptr); +// virtual uint64_t blockchainTargetHeight() = 0; +extern ADDAPI uint64_t MONERO_WalletManager_blockchainTargetHeight(void* wm_ptr); +// virtual uint64_t networkDifficulty() = 0; +extern ADDAPI uint64_t MONERO_WalletManager_networkDifficulty(void* wm_ptr); +// virtual double miningHashRate() = 0; +extern ADDAPI double MONERO_WalletManager_miningHashRate(void* wm_ptr); +// virtual uint64_t blockTarget() = 0; +extern ADDAPI uint64_t MONERO_WalletManager_blockTarget(void* wm_ptr); +// virtual bool isMining() = 0; +extern ADDAPI bool MONERO_WalletManager_isMining(void* wm_ptr); +// virtual bool startMining(const std::string &address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true) = 0; +extern ADDAPI bool MONERO_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery); +// virtual bool stopMining() = 0; +extern ADDAPI bool MONERO_WalletManager_stopMining(void* wm_ptr, const char* address); +// virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0; +extern ADDAPI const char* MONERO_WalletManager_resolveOpenAlias(void* wm_ptr, const char* address, bool dnssec_valid); +// static std::tuple checkUpdates( +// const std::string &software, +// std::string subdir, +// const char *buildtag = nullptr, +// const char *current_version = nullptr); +// virtual bool setProxy(const std::string &address) = 0; +extern ADDAPI bool MONERO_WalletManager_setProxy(void* wm_ptr, const char* address); +// }; + +extern ADDAPI const int MONERO_LogLevel_Silent; +extern ADDAPI const int MONERO_LogLevel_0; +extern ADDAPI const int MONERO_LogLevel_1; +extern ADDAPI const int MONERO_LogLevel_2; +extern ADDAPI const int MONERO_LogLevel_3; +extern ADDAPI const int MONERO_LogLevel_4; +extern ADDAPI const int MONERO_LogLevel_Min; +extern ADDAPI const int MONERO_LogLevel_Max; + +// struct WalletManagerFactory +// { +// enum LogLevel { +// LogLevel_Silent = -1, +// LogLevel_0 = 0, +// LogLevel_1 = 1, +// LogLevel_2 = 2, +// LogLevel_3 = 3, +// LogLevel_4 = 4, +// LogLevel_Min = LogLevel_Silent, +// LogLevel_Max = LogLevel_4 +// }; +// static WalletManager * getWalletManager(); +extern ADDAPI void* MONERO_WalletManagerFactory_getWalletManager(); +// static void setLogLevel(int level); +extern ADDAPI void MONERO_WalletManagerFactory_setLogLevel(int level); +// static void setLogCategories(const std::string &categories); +extern ADDAPI void MONERO_WalletManagerFactory_setLogCategories(const char* categories); +// }; +// } + +extern ADDAPI void MONERO_DEBUG_test0(); +extern ADDAPI bool MONERO_DEBUG_test1(bool x); +extern ADDAPI int MONERO_DEBUG_test2(int x); +extern ADDAPI uint64_t MONERO_DEBUG_test3(uint64_t x); +extern ADDAPI void* MONERO_DEBUG_test4(uint64_t x); +extern ADDAPI const char* MONERO_DEBUG_test5(); +extern ADDAPI const char* MONERO_DEBUG_test5_std(); +extern ADDAPI bool MONERO_DEBUG_isPointerNull(void* wallet_ptr); + +// cake world + +extern ADDAPI void* MONERO_cw_getWalletListener(void* wallet_ptr); +extern ADDAPI void MONERO_cw_WalletListener_resetNeedToRefresh(void* cw_walletListener_ptr); +extern ADDAPI bool MONERO_cw_WalletListener_isNeedToRefresh(void* cw_walletListener_ptr); +extern ADDAPI bool MONERO_cw_WalletListener_isNewTransactionExist(void* cw_walletListener_ptr); +extern ADDAPI void MONERO_cw_WalletListener_resetIsNewTransactionExist(void* cw_walletListener_ptr); +extern ADDAPI uint64_t MONERO_cw_WalletListener_height(void* cw_walletListener_ptr); + +extern ADDAPI void MONERO_free(void* ptr); + +extern ADDAPI const char* MONERO_checksum_wallet2_api_c_h(); +extern ADDAPI const char* MONERO_checksum_wallet2_api_c_cpp(); +extern ADDAPI const char* MONERO_checksum_wallet2_api_c_exp(); + +#ifdef __cplusplus +} +#endif + +#endif // MONERO_LIBWALLET2_API_C_H diff --git a/monero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp b/monero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp deleted file mode 100644 index c58fbec..0000000 --- a/monero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp +++ /dev/null @@ -1,2630 +0,0 @@ -#include -#include "wallet2_api_c.h" -#include -#include "helpers.hpp" -#include -#include -#include "../../../../monero/src/wallet/api/wallet2_api.h" -#include "monero_checksum.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - - -// The code in here consists of simple wrappers, that convert -// more advanced c++ types (and function names) into simple C-compatible -// functions, so these implementations can be easly used from all languages -// that do support C interop (such as dart) -// -// -// Here is the most complex definition that we can find in the current codebase, it even includes -// a if statement - which in general I consider an anti-patter in just wrappers -// -// _____________ void* because C++ wallet->createTransaction returns a pointer to Monero::PendingTransaction, which we don't want to have exposed in C land -// / _____________ MONERO prefix just means that this function is using monero codebase, to not cause any symbols collision when using more than one libwallet2_api_c.so in a single program. -// | / _____________ Wallet is one of the classes in Monero namespace in the upstream codebase (see the include line above) -// | | / _____________ aaand it is calling createTransaction function. -// | | | / _________________________________________________________________________________ -// | | | | / \ All of these parameters can be found in the upstream -// | | | | | _____________/ function definition, if something was more complex - -// void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, / like std::set I've used splitString functions and introduced a new -// uint64_t amount, uint32_t mixin_count, / parameter - separator, as it is the simplest way to get vector onto -// int pendingTransactionPriority, / C side from more advanced world. -// uint32_t subaddr_account, / -// const char* preferredInputs, const char* separator) { -// Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); <------------ We are converting the void* into Monero::Wallet* -// Monero::optional optAmount; <------------- optional by default -// if (amount != 0) {------------------\ We set this optional parameter only when it isn't zero -// optAmount = amount; | -// }___________________________________/ -// std::set subaddr_indices = {}; ------------- Default value -// std::set preferred_inputs = splitString(std::string(preferredInputs), std::string(separator)); <------------- We are using helpers.cpp function to split a string into std::set -// return wallet->createTransaction(std::string(dst_addr), std::string(payment_id),-\ const char * is getting casted onto std::string -// optAmount, mixin_count, \_____________/ -// PendingTransaction_Priority_fromInt(pendingTransactionPriority), <------------- special case for this function to get native type instead of int value. -// subaddr_account, subaddr_indices, preferred_inputs); -// } -// -// -// One case which is not covered here is when we have to return a string -// const char* MONERO_PendingTransaction_errorString(void* pendingTx_ptr) { -// Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); -// std::string str = pendingTx->errorString(); <------------- get the actual string from the upstream codebase -// const std::string::size_type size = str.size(); ------------------------------\ -// char *buffer = new char[size + 1]; //we need extra char for NUL | Copy the string onto a new memory so it won't get freed after the function returns -// memcpy(buffer, str.c_str(), size + 1); | NOTE: This requires us to call free() after we are done with the text processing -// return buffer; ______________________________________________________________/ -// } -// -// - -// PendingTransaction - -int MONERO_PendingTransaction_status(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - return pendingTx->status(); - DEBUG_END() -} -const char* MONERO_PendingTransaction_errorString(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::string str = pendingTx->errorString(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -bool MONERO_PendingTransaction_commit(void* pendingTx_ptr, const char* filename, bool overwrite) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - return pendingTx->commit(std::string(filename), overwrite); - DEBUG_END() -} -const char* MONERO_PendingTransaction_commitUR(void* pendingTx_ptr, int max_fragment_length) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::string str = pendingTx->commitUR(max_fragment_length); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -uint64_t MONERO_PendingTransaction_amount(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - return pendingTx->amount(); - DEBUG_END() -} -uint64_t MONERO_PendingTransaction_dust(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - return pendingTx->dust(); - DEBUG_END() -} -uint64_t MONERO_PendingTransaction_fee(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - return pendingTx->fee(); - DEBUG_END() -} -const char* MONERO_PendingTransaction_txid(void* pendingTx_ptr, const char* separator) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::vector txid = pendingTx->txid(); - return vectorToString(txid, std::string(separator)); - DEBUG_END() -} -uint64_t MONERO_PendingTransaction_txCount(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - return pendingTx->txCount(); - DEBUG_END() -} -const char* MONERO_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::vector subaddrAccount = pendingTx->subaddrAccount(); - return vectorToString(subaddrAccount, std::string(separator)); - DEBUG_END() -} -const char* MONERO_PendingTransaction_subaddrIndices(void* pendingTx_ptr, const char* separator) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::vector> subaddrIndices = pendingTx->subaddrIndices(); - return vectorToString(subaddrIndices, std::string(separator)); - DEBUG_END() -} -const char* MONERO_PendingTransaction_multisigSignData(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::string str = pendingTx->multisigSignData(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -void MONERO_PendingTransaction_signMultisigTx(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - return pendingTx->signMultisigTx(); - DEBUG_END() -} -const char* MONERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::vector txid = pendingTx->signersKeys(); - return vectorToString(txid, std::string(separator)); - DEBUG_END() -} - -const char* MONERO_PendingTransaction_hex(void* pendingTx_ptr, const char* separator) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::vector txid = pendingTx->hex(); - return vectorToString(txid, std::string(separator)); - DEBUG_END() -} - -const char* MONERO_PendingTransaction_txKey(void* pendingTx_ptr, const char* separator) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::vector txid = pendingTx->txKey(); - return vectorToString(txid, std::string(separator)); - DEBUG_END() -} - -// UnsignedTransaction - -int MONERO_UnsignedTransaction_status(void* unsignedTx_ptr) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return unsignedTx->status(); - DEBUG_END() -} -const char* MONERO_UnsignedTransaction_errorString(void* unsignedTx_ptr) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - std::string str = unsignedTx->errorString(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -const char* MONERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return vectorToString(unsignedTx->amount(), std::string(separator)); - DEBUG_END() -} -const char* MONERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return vectorToString(unsignedTx->fee(), std::string(separator)); - DEBUG_END() -} -const char* MONERO_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return vectorToString(unsignedTx->mixin(), std::string(separator)); - DEBUG_END() -} -const char* MONERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - std::string str = unsignedTx->confirmationMessage(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -const char* MONERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return vectorToString(unsignedTx->paymentId(), std::string(separator)); - DEBUG_END() -} -const char* MONERO_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return vectorToString(unsignedTx->recipientAddress(), std::string(separator)); - DEBUG_END() -} -uint64_t MONERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return unsignedTx->minMixinCount(); - DEBUG_END() -} -uint64_t MONERO_UnsignedTransaction_txCount(void* unsignedTx_ptr) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return unsignedTx->txCount(); - DEBUG_END() -} -bool MONERO_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return unsignedTx->sign(std::string(signedFileName)); - DEBUG_END() -} -const char* MONERO_UnsignedTransaction_signUR(void* unsignedTx_ptr, int max_fragment_length) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - std::string str = unsignedTx->signUR(max_fragment_length); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// TransactionInfo -int MONERO_TransactionInfo_direction(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->direction(); - DEBUG_END() -} -bool MONERO_TransactionInfo_isPending(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->isPending(); - DEBUG_END() -} -bool MONERO_TransactionInfo_isFailed(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->isFailed(); - DEBUG_END() -} -bool MONERO_TransactionInfo_isCoinbase(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->isCoinbase(); - DEBUG_END() -} -uint64_t MONERO_TransactionInfo_amount(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->amount(); - DEBUG_END() -} -uint64_t MONERO_TransactionInfo_fee(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->fee(); - DEBUG_END() -} -uint64_t MONERO_TransactionInfo_blockHeight(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->blockHeight(); - DEBUG_END() -} -const char* MONERO_TransactionInfo_description(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - std::string str = txInfo->description(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -const char* MONERO_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - std::set subaddrIndex = txInfo->subaddrIndex(); - return vectorToString(subaddrIndex, std::string(separator)); - DEBUG_END() -} -uint32_t MONERO_TransactionInfo_subaddrAccount(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->subaddrAccount(); - DEBUG_END() -} -const char* MONERO_TransactionInfo_label(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - std::string str = txInfo->label(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -uint64_t MONERO_TransactionInfo_confirmations(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->confirmations(); - DEBUG_END() -} -uint64_t MONERO_TransactionInfo_unlockTime(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->unlockTime(); - DEBUG_END() -} -const char* MONERO_TransactionInfo_hash(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - std::string str = txInfo->hash(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -uint64_t MONERO_TransactionInfo_timestamp(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->timestamp(); - DEBUG_END() -} -const char* MONERO_TransactionInfo_paymentId(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - std::string str = txInfo->paymentId(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -int MONERO_TransactionInfo_transfers_count(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->transfers().size(); - DEBUG_END() -} - -uint64_t MONERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->transfers()[index].amount; - DEBUG_END() -} - -const char* MONERO_TransactionInfo_transfers_address(void* txInfo_ptr, int index) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - std::string str = txInfo->transfers()[index].address; - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - - - - -// TransactionHistory -int MONERO_TransactionHistory_count(void* txHistory_ptr) { - DEBUG_START() - Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); - return txHistory->count(); - DEBUG_END() -} -void* MONERO_TransactionHistory_transaction(void* txHistory_ptr, int index) { - DEBUG_START() - Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); - return reinterpret_cast(txHistory->transaction(index)); - DEBUG_END() -} -void* MONERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id) { - DEBUG_START() - Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); - return reinterpret_cast(txHistory->transaction(std::string(id))); - DEBUG_END() -} - -void MONERO_TransactionHistory_refresh(void* txHistory_ptr) { - DEBUG_START() - Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); - return txHistory->refresh(); - DEBUG_END() -} -void MONERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note) { - DEBUG_START() - Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); - return txHistory->setTxNote(std::string(txid), std::string(note)); - DEBUG_END() -} - -// AddressBokRow - -// std::string extra; -const char* MONERO_AddressBookRow_extra(void* addressBookRow_ptr) { - DEBUG_START() - Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); - std::string str = addressBookRow->extra; - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getAddress() const {return m_address;} -const char* MONERO_AddressBookRow_getAddress(void* addressBookRow_ptr) { - DEBUG_START() - Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); - std::string str = addressBookRow->getAddress(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getDescription() const {return m_description;} -const char* MONERO_AddressBookRow_getDescription(void* addressBookRow_ptr) { - DEBUG_START() - Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); - std::string str = addressBookRow->getDescription(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getPaymentId() const {return m_paymentId;} -const char* MONERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr) { - DEBUG_START() - Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); - std::string str = addressBookRow->getPaymentId(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::size_t getRowId() const {return m_rowId;} -size_t MONERO_AddressBookRow_getRowId(void* addressBookRow_ptr) { - DEBUG_START() - Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); - return addressBookRow->getRowId(); - DEBUG_END() -} - -// AddressBook -// virtual std::vector getAll() const = 0; -int MONERO_AddressBook_getAll_size(void* addressBook_ptr) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->getAll().size(); - DEBUG_END() -} -void* MONERO_AddressBook_getAll_byIndex(void* addressBook_ptr, int index) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->getAll()[index]; - DEBUG_END() -} -// virtual bool addRow(const std::string &dst_addr , const std::string &payment_id, const std::string &description) = 0; -bool MONERO_AddressBook_addRow(void* addressBook_ptr, const char* dst_addr , const char* payment_id, const char* description) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->addRow(std::string(dst_addr), std::string(payment_id), std::string(description)); - DEBUG_END() -} -// virtual bool deleteRow(std::size_t rowId) = 0; -bool MONERO_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->deleteRow(rowId); - DEBUG_END() -} -// virtual bool setDescription(std::size_t index, const std::string &description) = 0; -bool MONERO_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->setDescription(rowId, std::string(description)); - DEBUG_END() -} -// virtual void refresh() = 0; -void MONERO_AddressBook_refresh(void* addressBook_ptr) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->refresh(); - DEBUG_END() -} -// virtual std::string errorString() const = 0; -const char* MONERO_AddressBook_errorString(void* addressBook_ptr) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - std::string str = addressBook->errorString(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual int errorCode() const = 0; -int MONERO_AddressBook_errorCode(void* addressBook_ptr) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->errorCode(); - DEBUG_END() -} -// virtual int lookupPaymentID(const std::string &payment_id) const = 0; -int MONERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->lookupPaymentID(std::string(payment_id)); - DEBUG_END() -} - -// CoinsInfo -uint64_t MONERO_CoinsInfo_blockHeight(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->blockHeight(); - DEBUG_END() -} -// virtual std::string hash() const = 0; -const char* MONERO_CoinsInfo_hash(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - std::string str = coinsInfo->hash(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual size_t internalOutputIndex() const = 0; -size_t MONERO_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->internalOutputIndex(); - DEBUG_END() -} -// virtual uint64_t globalOutputIndex() const = 0; -uint64_t MONERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->globalOutputIndex(); - DEBUG_END() -} -// virtual bool spent() const = 0; -bool MONERO_CoinsInfo_spent(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->spent(); - DEBUG_END() -} -// virtual bool frozen() const = 0; -bool MONERO_CoinsInfo_frozen(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->frozen(); - DEBUG_END() -} -// virtual uint64_t spentHeight() const = 0; -uint64_t MONERO_CoinsInfo_spentHeight(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->spentHeight(); - DEBUG_END() -} -// virtual uint64_t amount() const = 0; -uint64_t MONERO_CoinsInfo_amount(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->amount(); - DEBUG_END() -} -// virtual bool rct() const = 0; -bool MONERO_CoinsInfo_rct(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->rct(); - DEBUG_END() -} -// virtual bool keyImageKnown() const = 0; -bool MONERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->keyImageKnown(); - DEBUG_END() -} -// virtual size_t pkIndex() const = 0; -size_t MONERO_CoinsInfo_pkIndex(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->pkIndex(); - DEBUG_END() -} -// virtual uint32_t subaddrIndex() const = 0; -uint32_t MONERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->subaddrIndex(); - DEBUG_END() -} -// virtual uint32_t subaddrAccount() const = 0; -uint32_t MONERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->subaddrAccount(); - DEBUG_END() -} -// virtual std::string address() const = 0; -const char* MONERO_CoinsInfo_address(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - std::string str = coinsInfo->address(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual std::string addressLabel() const = 0; -const char* MONERO_CoinsInfo_addressLabel(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - std::string str = coinsInfo->addressLabel(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual std::string keyImage() const = 0; -const char* MONERO_CoinsInfo_keyImage(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - std::string str = coinsInfo->keyImage(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual uint64_t unlockTime() const = 0; -uint64_t MONERO_CoinsInfo_unlockTime(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->unlockTime(); - DEBUG_END() -} -// virtual bool unlocked() const = 0; -bool MONERO_CoinsInfo_unlocked(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->unlocked(); - DEBUG_END() -} -// virtual std::string pubKey() const = 0; -const char* MONERO_CoinsInfo_pubKey(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - std::string str = coinsInfo->pubKey(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual bool coinbase() const = 0; -bool MONERO_CoinsInfo_coinbase(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->coinbase(); - DEBUG_END() -} -// virtual std::string description() const = 0; -const char* MONERO_CoinsInfo_description(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - std::string str = coinsInfo->description(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - - -// coins - -// virtual ~Coins() = 0; -// virtual int count() const = 0; -int MONERO_Coins_count(void* coins_ptr) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->count(); - DEBUG_END() -} -// virtual CoinsInfo * coin(int index) const = 0; -void* MONERO_Coins_coin(void* coins_ptr, int index) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->coin(index); - DEBUG_END() -} - -int MONERO_Coins_getAll_size(void* coins_ptr) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->getAll().size(); - DEBUG_END() -} -void* MONERO_Coins_getAll_byIndex(void* coins_ptr, int index) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->getAll()[index]; - DEBUG_END() -} - -// virtual std::vector getAll() const = 0; -// virtual void refresh() = 0; -void MONERO_Coins_refresh(void* coins_ptr) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->refresh(); - DEBUG_END() -} -// virtual void setFrozen(std::string public_key) = 0; -void MONERO_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->setFrozen(std::string(public_key)); - DEBUG_END() -} -// virtual void setFrozen(int index) = 0; -void MONERO_Coins_setFrozen(void* coins_ptr, int index) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->setFrozen(index); - DEBUG_END() -} -// virtual void thaw(int index) = 0; -void MONERO_Coins_thaw(void* coins_ptr, int index) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->thaw(index); - DEBUG_END() -} -// virtual void thaw(std::string public_key) = 0; -void MONERO_Coins_thawByPublicKey(void* coins_ptr, const char* public_key) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->thaw(std::string(public_key)); - DEBUG_END() -} -// virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0; -bool MONERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->isTransferUnlocked(unlockTime, blockHeight); - DEBUG_END() -} -// virtual void setDescription(const std::string &public_key, const std::string &description) = 0; -void MONERO_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->setDescription(std::string(public_key), std::string(description)); - DEBUG_END() -} - -// SubaddressRow - -// std::string extra; -const char* MONERO_SubaddressRow_extra(void* subaddressRow_ptr) { - DEBUG_START() - Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); - std::string str = subaddressRow->extra; - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getAddress() const {return m_address;} -const char* MONERO_SubaddressRow_getAddress(void* subaddressRow_ptr) { - DEBUG_START() - Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); - std::string str = subaddressRow->getAddress(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getLabel() const {return m_label;} -const char* MONERO_SubaddressRow_getLabel(void* subaddressRow_ptr) { - DEBUG_START() - Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); - std::string str = subaddressRow->getLabel(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::size_t getRowId() const {return m_rowId;} -size_t MONERO_SubaddressRow_getRowId(void* subaddressRow_ptr) { - DEBUG_START() - Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); - return subaddressRow->getRowId(); - DEBUG_END() -} - -// Subaddress - -int MONERO_Subaddress_getAll_size(void* subaddress_ptr) { - DEBUG_START() - Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); - return subaddress->getAll().size(); - DEBUG_END() -} -void* MONERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index) { - DEBUG_START() - Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); - return subaddress->getAll()[index]; - DEBUG_END() -} -// virtual void addRow(uint32_t accountIndex, const std::string &label) = 0; -void MONERO_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label) { - DEBUG_START() - Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); - return subaddress->addRow(accountIndex, std::string(label)); - DEBUG_END() -} -// virtual void setLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0; -void MONERO_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label) { - DEBUG_START() - Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); - return subaddress->setLabel(accountIndex, addressIndex, std::string(label)); - DEBUG_END() -} -// virtual void refresh(uint32_t accountIndex) = 0; -void MONERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex) { - DEBUG_START() - Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); - return subaddress->refresh(accountIndex); - DEBUG_END() -} - -// SubaddressAccountRow - -// std::string extra; -const char* MONERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr) { - DEBUG_START() - Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); - std::string str = subaddressAccountRow->extra; - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getAddress() const {return m_address;} -const char* MONERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr) { - DEBUG_START() - Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); - std::string str = subaddressAccountRow->getAddress(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getLabel() const {return m_label;} -const char* MONERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr) { - DEBUG_START() - Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); - std::string str = subaddressAccountRow->getLabel(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getBalance() const {return m_balance;} -const char* MONERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr) { - DEBUG_START() - Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); - std::string str = subaddressAccountRow->getBalance(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getUnlockedBalance() const {return m_unlockedBalance;} -const char* MONERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr) { - DEBUG_START() - Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); - std::string str = subaddressAccountRow->getUnlockedBalance(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::size_t getRowId() const {return m_rowId;} -size_t MONERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr) { - DEBUG_START() - Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); - return subaddressAccountRow->getRowId(); - DEBUG_END() -} - -// struct SubaddressAccount -// { -// virtual ~SubaddressAccount() = 0; -// virtual std::vector getAll() const = 0; -int MONERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr) { - DEBUG_START() - Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); - return subaddress->getAll().size(); - DEBUG_END() -} -void* MONERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index) { - DEBUG_START() - Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); - return subaddress->getAll()[index]; - DEBUG_END() -} -// virtual void addRow(const std::string &label) = 0; -void MONERO_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label) { - DEBUG_START() - Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); - return subaddress->addRow(std::string(label)); - DEBUG_END() -} -// virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0; -void MONERO_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label) { - DEBUG_START() - Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); - return subaddress->setLabel(accountIndex, std::string(label)); - DEBUG_END() -} -// virtual void refresh() = 0; -void MONERO_SubaddressAccount_refresh(void* subaddressAccount_ptr) { - DEBUG_START() - Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); - return subaddress->refresh(); - DEBUG_END() -} - -// MultisigState - -// bool isMultisig; -bool MONERO_MultisigState_isMultisig(void* multisigState_ptr) { - DEBUG_START() - Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); - return multisigState->isMultisig; - DEBUG_END() -} -// bool isReady; -bool MONERO_MultisigState_isReady(void* multisigState_ptr) { - DEBUG_START() - Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); - return multisigState->isReady; - DEBUG_END() -} -// uint32_t threshold; -uint32_t MONERO_MultisigState_threshold(void* multisigState_ptr) { - DEBUG_START() - Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); - return multisigState->threshold; - DEBUG_END() -} -// uint32_t total; -uint32_t MONERO_MultisigState_total(void* multisigState_ptr) { - DEBUG_START() - Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); - return multisigState->total; - DEBUG_END() -} - -// DeviceProgress - - -// virtual double progress() const { return m_progress; } -bool MONERO_DeviceProgress_progress(void* deviceProgress_ptr) { - DEBUG_START() - Monero::DeviceProgress *deviceProgress = reinterpret_cast(deviceProgress_ptr); - return deviceProgress->progress(); - DEBUG_END() -} -// virtual bool indeterminate() const { return m_indeterminate; } -bool MONERO_DeviceProgress_indeterminate(void* deviceProgress_ptr) { - DEBUG_START() - Monero::DeviceProgress *deviceProgress = reinterpret_cast(deviceProgress_ptr); - return deviceProgress->indeterminate(); - DEBUG_END() -} - -// Wallet - -const char* MONERO_Wallet_seed(void* wallet_ptr, const char* seed_offset) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->seed(std::string(seed_offset)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* MONERO_Wallet_getSeedLanguage(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->getSeedLanguage(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -void MONERO_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setSeedLanguage(std::string(arg)); - DEBUG_END() -} - -int MONERO_Wallet_status(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->status(); - DEBUG_END() -} - -const char* MONERO_Wallet_errorString(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->errorString(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - - -bool MONERO_Wallet_setPassword(void* wallet_ptr, const char* password) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setPassword(std::string(password)); - DEBUG_END() -} - -const char* MONERO_Wallet_getPassword(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->getPassword(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -bool MONERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setDevicePin(std::string(pin)); - DEBUG_END() -} - -bool MONERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setDevicePassphrase(std::string(passphrase)); - DEBUG_END() -} - -const char* MONERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->address(accountIndex, addressIndex); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* MONERO_Wallet_path(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->path(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -int MONERO_Wallet_nettype(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->nettype(); - DEBUG_END() -} -uint8_t MONERO_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->useForkRules(version, early_blocks); - DEBUG_END() -} -const char* MONERO_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->integratedAddress(std::string(payment_id)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* MONERO_Wallet_secretViewKey(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->secretViewKey(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* MONERO_Wallet_publicViewKey(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->publicViewKey(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* MONERO_Wallet_secretSpendKey(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->secretSpendKey(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* MONERO_Wallet_publicSpendKey(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->publicSpendKey(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -const char* MONERO_Wallet_publicMultisigSignerKey(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->publicMultisigSignerKey(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -void MONERO_Wallet_stop(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->stop(); - DEBUG_END() -} - -bool MONERO_Wallet_store(void* wallet_ptr, const char* path) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->store(std::string(path)); - DEBUG_END() -} -const char* MONERO_Wallet_filename(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->filename(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -const char* MONERO_Wallet_keysFilename(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->keysFilename(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -// virtual bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit = 0, const std::string &daemon_username = "", const std::string &daemon_password = "", bool use_ssl = false, bool lightWallet = false, const std::string &proxy_address = "") = 0; -bool MONERO_Wallet_init(void* wallet_ptr, const char* daemon_address, uint64_t upper_transaction_size_limit, const char* daemon_username, const char* daemon_password, bool use_ssl, bool lightWallet, const char* proxy_address) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->init(std::string(daemon_address), upper_transaction_size_limit, std::string(daemon_username), std::string(daemon_password), use_ssl, lightWallet, std::string(proxy_address)); - DEBUG_END() -} -bool MONERO_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->createWatchOnly(std::string(path), std::string(password), std::string(language)); - DEBUG_END() -} - -void MONERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setRefreshFromBlockHeight(refresh_from_block_height); - DEBUG_END() -} - -uint64_t MONERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->getRefreshFromBlockHeight(); - DEBUG_END() -} - -void MONERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setRecoveringFromSeed(recoveringFromSeed); - DEBUG_END() -} -void MONERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setRecoveringFromDevice(recoveringFromDevice); - DEBUG_END() -} -void MONERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setSubaddressLookahead(major, minor); - DEBUG_END() -} - -bool MONERO_Wallet_connectToDaemon(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->connectToDaemon(); - DEBUG_END() -} -int MONERO_Wallet_connected(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->connected(); - DEBUG_END() -} -void MONERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setTrustedDaemon(arg); - DEBUG_END() -} -bool MONERO_Wallet_trustedDaemon(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->trustedDaemon(); - DEBUG_END() -} -bool MONERO_Wallet_setProxy(void* wallet_ptr, const char* address) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setProxy(std::string(address)); - DEBUG_END() -} - -uint64_t MONERO_Wallet_balance(void* wallet_ptr, uint32_t accountIndex) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->balance(accountIndex); - DEBUG_END() -} - -uint64_t MONERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->unlockedBalance(accountIndex); - DEBUG_END() -} - -uint64_t MONERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->viewOnlyBalance(accountIndex); - DEBUG_END() -} - -// TODO -bool MONERO_Wallet_watchOnly(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->watchOnly(); - DEBUG_END() -} -bool MONERO_Wallet_isDeterministic(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->isDeterministic(); - DEBUG_END() -} -uint64_t MONERO_Wallet_blockChainHeight(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->blockChainHeight(); - DEBUG_END() -} -uint64_t MONERO_Wallet_approximateBlockChainHeight(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->approximateBlockChainHeight(); - DEBUG_END() -} -uint64_t MONERO_Wallet_estimateBlockChainHeight(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->estimateBlockChainHeight(); - DEBUG_END() -} -uint64_t MONERO_Wallet_daemonBlockChainHeight(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->daemonBlockChainHeight(); - DEBUG_END() -} - -uint64_t MONERO_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->daemonBlockChainTargetHeight(); - DEBUG_END() -} -bool MONERO_Wallet_synchronized(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->synchronized(); - DEBUG_END() -} - -const char* MONERO_Wallet_displayAmount(uint64_t amount) { - DEBUG_START() - std::string str = Monero::Wallet::displayAmount(amount); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -// static uint64_t amountFromString(const std::string &amount); -uint64_t MONERO_Wallet_amountFromString(const char* amount) { - DEBUG_START() - return Monero::Wallet::amountFromString(amount); - DEBUG_END() -} -// static uint64_t amountFromDouble(double amount); -uint64_t MONERO_Wallet_amountFromDouble(double amount) { - DEBUG_START() - return Monero::Wallet::amountFromDouble(amount); - DEBUG_END() -} -// static std::string genPaymentId(); -const char* MONERO_Wallet_genPaymentId() { - DEBUG_START() - std::string str = Monero::Wallet::genPaymentId(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// static bool paymentIdValid(const std::string &paiment_id); -bool MONERO_Wallet_paymentIdValid(const char* paiment_id) { - DEBUG_START() - return Monero::Wallet::paymentIdValid(std::string(paiment_id)); - DEBUG_END() -} -bool MONERO_Wallet_addressValid(const char* str, int nettype) { - DEBUG_START() - // Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return Monero::Wallet::addressValid(std::string(str), nettype); - DEBUG_END() -} - -bool MONERO_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype) { - DEBUG_START() - std::string error; - return Monero::Wallet::keyValid(std::string(secret_key_string), std::string(address_string), isViewKey, nettype, error); - DEBUG_END() -} -const char* MONERO_Wallet_keyValid_error(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype) { - DEBUG_START() - std::string str; - Monero::Wallet::keyValid(std::string(secret_key_string), std::string(address_string), isViewKey, nettype, str); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() - -} -const char* MONERO_Wallet_paymentIdFromAddress(const char* strarg, int nettype) { - DEBUG_START() - std::string str = Monero::Wallet::paymentIdFromAddress(std::string(strarg), nettype); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -uint64_t MONERO_Wallet_maximumAllowedAmount() { - DEBUG_START() - return Monero::Wallet::maximumAllowedAmount(); - DEBUG_END() -} - -void MONERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->init(argv0, default_log_base_name, log_path, console); - DEBUG_END() -} -const char* MONERO_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string seed = ""; - std::string _passphrase = std::string(passphrase); - wallet->getPolyseed(seed, _passphrase); - std::string str = seed; - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// static bool createPolyseed(std::string &seed_words, std::string &err, const std::string &language = "English"); -const char* MONERO_Wallet_createPolyseed(const char* language) { - DEBUG_START() - std::string seed_words = ""; - std::string err; - Monero::Wallet::createPolyseed(seed_words, err, std::string(language)); - std::cout << "MONERO_Wallet_createPolyseed(language: " << language << "):" << std::endl; - std::cout << " err: " << err << std::endl; - std::string str = seed_words; - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -void MONERO_Wallet_startRefresh(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->startRefresh(); - DEBUG_END() -} -void MONERO_Wallet_pauseRefresh(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->pauseRefresh(); - DEBUG_END() -} -bool MONERO_Wallet_refresh(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->refresh(); - DEBUG_END() -} -void MONERO_Wallet_refreshAsync(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->refreshAsync(); - DEBUG_END() -} -bool MONERO_Wallet_rescanBlockchain(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->rescanBlockchain(); - DEBUG_END() -} -void MONERO_Wallet_rescanBlockchainAsync(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->rescanBlockchainAsync(); - DEBUG_END() -} -void MONERO_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setAutoRefreshInterval(millis); - DEBUG_END() -} -int MONERO_Wallet_autoRefreshInterval(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->autoRefreshInterval(); - DEBUG_END() -} -void MONERO_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->addSubaddressAccount(std::string(label)); - DEBUG_END() -} -size_t MONERO_Wallet_numSubaddressAccounts(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->numSubaddressAccounts(); - DEBUG_END() -} -size_t MONERO_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->numSubaddresses(accountIndex); - DEBUG_END() -} -void MONERO_Wallet_addSubaddress(void* wallet_ptr, uint32_t accountIndex, const char* label) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->addSubaddress(accountIndex, std::string(label)); - DEBUG_END() -} -const char* MONERO_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->getSubaddressLabel(accountIndex, addressIndex); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -void MONERO_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setSubaddressLabel(accountIndex, addressIndex, std::string(label)); - DEBUG_END() -} - -void* MONERO_Wallet_multisig(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - Monero::MultisigState *mstate_ptr = new Monero::MultisigState(wallet->multisig()); - return reinterpret_cast(mstate_ptr); - DEBUG_END() -} - -const char* MONERO_Wallet_getMultisigInfo(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->getMultisigInfo(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* MONERO_Wallet_makeMultisig(void* wallet_ptr, const char* info, const char* info_separator, uint32_t threshold) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->makeMultisig(splitStringVector(std::string(info), std::string(info_separator)), threshold); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* MONERO_Wallet_exchangeMultisigKeys(void* wallet_ptr, const char* info, const char* info_separator, bool force_update_use_with_caution) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->exchangeMultisigKeys(splitStringVector(std::string(info), std::string(info_separator)), force_update_use_with_caution); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* MONERO_Wallet_exportMultisigImages(void* wallet_ptr, const char* separator) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str; - wallet->exportMultisigImages(str); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -size_t MONERO_Wallet_importMultisigImages(void* wallet_ptr, const char* info, const char* info_separator) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->importMultisigImages(splitStringVector(std::string(info), std::string(info_separator))); - DEBUG_END() -} - -size_t MONERO_Wallet_hasMultisigPartialKeyImages(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->hasMultisigPartialKeyImages(); - DEBUG_END() -} - -void* MONERO_Wallet_restoreMultisigTransaction(void* wallet_ptr, const char* signData) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return reinterpret_cast(wallet->restoreMultisigTransaction(std::string(signData))); - DEBUG_END() -} - - -Monero::PendingTransaction::Priority PendingTransaction_Priority_fromInt(int value) { - switch(value) { - case 0: return Monero::PendingTransaction::Priority::Priority_Default; - case 1: return Monero::PendingTransaction::Priority::Priority_Low; - case 2: return Monero::PendingTransaction::Priority::Priority_Medium; - case 3: return Monero::PendingTransaction::Priority::Priority_High; - default: return Monero::PendingTransaction::Priority::Priority_Default; - } -} - -void* MONERO_Wallet_createTransactionMultDest(void* wallet_ptr, const char* dst_addr_list, const char* dst_addr_list_separator, const char* payment_id, - bool amount_sweep_all, const char* amount_list, const char* amount_list_separator, uint32_t mixin_count, - int pendingTransactionPriority, - uint32_t subaddr_account, - const char* preferredInputs, const char* preferredInputs_separator) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::vector dst_addr = splitStringVector(std::string(dst_addr_list), std::string(dst_addr_list_separator)); - - Monero::optional> optAmount; - if (!amount_sweep_all) { - optAmount = splitStringUint(std::string(amount_list), std::string(amount_list_separator));; - } - std::set subaddr_indices = {}; - std::set preferred_inputs = splitString(std::string(preferredInputs), std::string(preferredInputs_separator)); - - return wallet->createTransactionMultDest( - dst_addr, std::string(payment_id), - optAmount, mixin_count, - PendingTransaction_Priority_fromInt(pendingTransactionPriority), - subaddr_account, - subaddr_indices, - preferred_inputs - ); - DEBUG_END() -} - -void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, - uint64_t amount, uint32_t mixin_count, - int pendingTransactionPriority, - uint32_t subaddr_account, - const char* preferredInputs, const char* separator) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - Monero::optional optAmount; - if (amount != 0) { - optAmount = amount; - } - std::set subaddr_indices = {}; - std::set preferred_inputs = splitString(std::string(preferredInputs), std::string(separator)); - return wallet->createTransaction(std::string(dst_addr), std::string(payment_id), - optAmount, mixin_count, - PendingTransaction_Priority_fromInt(pendingTransactionPriority), - subaddr_account, subaddr_indices, preferred_inputs); - DEBUG_END() -} - -void* MONERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* fileName) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->loadUnsignedTx(std::string(fileName)); - DEBUG_END() -} - -void* MONERO_Wallet_loadUnsignedTxUR(void* wallet_ptr, const char* input) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->loadUnsignedTxUR(std::string(input)); - DEBUG_END() -} -bool MONERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->submitTransaction(std::string(fileName)); - DEBUG_END() -} -bool MONERO_Wallet_submitTransactionUR(void* wallet_ptr, const char* input) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->submitTransactionUR(std::string(input)); - DEBUG_END() -} -bool MONERO_Wallet_hasUnknownKeyImages(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->hasUnknownKeyImages(); - DEBUG_END() -} -bool MONERO_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->exportKeyImages(std::string(filename), all); - DEBUG_END() -} - -const char* MONERO_Wallet_exportKeyImagesUR(void* wallet_ptr, size_t max_fragment_length, bool all) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->exportKeyImagesUR(max_fragment_length, all); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -bool MONERO_Wallet_importKeyImages(void* wallet_ptr, const char* filename) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->importKeyImages(std::string(filename)); - DEBUG_END() -} -bool MONERO_Wallet_importKeyImagesUR(void* wallet_ptr, const char* input) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->importKeyImagesUR(std::string(input)); - DEBUG_END() -} -bool MONERO_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool all) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->exportOutputs(std::string(filename), all); - DEBUG_END() -} -const char* MONERO_Wallet_exportOutputsUR(void* wallet_ptr, size_t max_fragment_length, bool all) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->exportOutputsUR(max_fragment_length, all); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -bool MONERO_Wallet_importOutputs(void* wallet_ptr, const char* filename) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->importOutputs(std::string(filename)); - DEBUG_END() -} -bool MONERO_Wallet_importOutputsUR(void* wallet_ptr, const char* input) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->importOutputsUR(std::string(input)); - DEBUG_END() -} -// virtual bool setupBackgroundSync(const BackgroundSyncType background_sync_type, const std::string &wallet_password, const optional &background_cache_password) = 0; -bool MONERO_Wallet_setupBackgroundSync(void* wallet_ptr, int background_sync_type, const char* wallet_password, const char* background_cache_password) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setupBackgroundSync(Monero::Wallet::BackgroundSyncType::BackgroundSync_CustomPassword, std::string(wallet_password), std::string(background_cache_password)); - DEBUG_END() -} -// virtual BackgroundSyncType getBackgroundSyncType() const = 0; -int MONERO_Wallet_getBackgroundSyncType(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->getBackgroundSyncType(); - DEBUG_END() -} -// virtual bool startBackgroundSync() = 0; -bool MONERO_Wallet_startBackgroundSync(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->startBackgroundSync(); - DEBUG_END() -} -// virtual bool stopBackgroundSync(const std::string &wallet_password) = 0; -bool MONERO_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->stopBackgroundSync(std::string(wallet_password)); - DEBUG_END() -} -// virtual bool isBackgroundSyncing() const = 0; -bool MONERO_Wallet_isBackgroundSyncing(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->hasUnknownKeyImages(); - DEBUG_END() -} -// virtual bool isBackgroundWallet() const = 0; -bool MONERO_Wallet_isBackgroundWallet(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->isBackgroundWallet(); - DEBUG_END() -} -void* MONERO_Wallet_history(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->history(); - DEBUG_END() -} -void* MONERO_Wallet_addressBook(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->addressBook(); - DEBUG_END() -} -// virtual Coins * coins() = 0; -void* MONERO_Wallet_coins(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->coins(); - DEBUG_END() -} -// virtual Subaddress * subaddress() = 0; -void* MONERO_Wallet_subaddress(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->subaddress(); - DEBUG_END() -} -// virtual SubaddressAccount * subaddressAccount() = 0; -void* MONERO_Wallet_subaddressAccount(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->subaddressAccount(); - DEBUG_END() -} -// virtual uint32_t defaultMixin() const = 0; -uint32_t MONERO_Wallet_defaultMixin(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->defaultMixin(); - DEBUG_END() -} -// virtual void setDefaultMixin(uint32_t arg) = 0; -void MONERO_Wallet_setDefaultMixin(void* wallet_ptr, uint32_t arg) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setDefaultMixin(arg); - DEBUG_END() -} -// virtual bool setCacheAttribute(const std::string &key, const std::string &val) = 0; -bool MONERO_Wallet_setCacheAttribute(void* wallet_ptr, const char* key, const char* val) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setCacheAttribute(std::string(key), std::string(val)); - DEBUG_END() -} -// virtual std::string getCacheAttribute(const std::string &key) const = 0; -const char* MONERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->getCacheAttribute(std::string(key)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual bool setUserNote(const std::string &txid, const std::string ¬e) = 0; -bool MONERO_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setUserNote(std::string(txid), std::string(note)); - DEBUG_END() -} -// virtual std::string getUserNote(const std::string &txid) const = 0; -const char* MONERO_Wallet_getUserNote(void* wallet_ptr, const char* txid) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->getUserNote(std::string(txid)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* MONERO_Wallet_getTxKey(void* wallet_ptr, const char* txid) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->getTxKey(std::string(txid)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* MONERO_Wallet_signMessage(void* wallet_ptr, const char* message, const char* address) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->signMessage(std::string(message), std::string(address)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -bool MONERO_Wallet_verifySignedMessage(void* wallet_ptr, const char* message, const char* address, const char* signature) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - bool v = wallet->verifySignedMessage(std::string(message), std::string(address), std::string(signature)); - return v; - DEBUG_END() -} - -bool MONERO_Wallet_rescanSpent(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->rescanSpent(); - DEBUG_END() -} - -void MONERO_Wallet_setOffline(void* wallet_ptr, bool offline) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setOffline(offline); - DEBUG_END() -} -// virtual bool isOffline() const = 0; -bool MONERO_Wallet_isOffline(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->isOffline(); - DEBUG_END() -} - -void MONERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->segregatePreForkOutputs(segregate); - DEBUG_END() -} -// virtual void segregationHeight(uint64_t height) = 0; -void MONERO_Wallet_segregationHeight(void* wallet_ptr, uint64_t height) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->segregationHeight(height); - DEBUG_END() -} -// virtual void keyReuseMitigation2(bool mitigation) = 0; -void MONERO_Wallet_keyReuseMitigation2(void* wallet_ptr, bool mitigation) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->keyReuseMitigation2(mitigation); - DEBUG_END() -} -// virtual bool lightWalletLogin(bool &isNewWallet) const = 0; -// virtual bool lightWalletImportWalletRequest(std::string &payment_id, uint64_t &fee, bool &new_request, bool &request_fulfilled, std::string &payment_address, std::string &status) = 0; -// virtual bool lockKeysFile() = 0; -bool MONERO_Wallet_lockKeysFile(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->lockKeysFile(); - DEBUG_END() -} -// virtual bool unlockKeysFile() = 0; -bool MONERO_Wallet_unlockKeysFile(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->unlockKeysFile(); - DEBUG_END() -} -// virtual bool isKeysFileLocked() = 0; -bool MONERO_Wallet_isKeysFileLocked(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->isKeysFileLocked(); - DEBUG_END() -} -// virtual Device getDeviceType() const = 0; -int MONERO_Wallet_getDeviceType(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->getDeviceType(); - DEBUG_END() -} -// virtual uint64_t coldKeyImageSync(uint64_t &spent, uint64_t &unspent) = 0; -uint64_t MONERO_Wallet_coldKeyImageSync(void* wallet_ptr, uint64_t spent, uint64_t unspent) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->coldKeyImageSync(spent, unspent); - DEBUG_END() -} -// virtual void deviceShowAddress(uint32_t accountIndex, uint32_t addressIndex, const std::string &paymentId) = 0; -const char* MONERO_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = ""; - wallet->deviceShowAddress(accountIndex, addressIndex, str); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual bool reconnectDevice() = 0; -bool MONERO_Wallet_reconnectDevice(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->reconnectDevice(); - DEBUG_END() -}; - -uint64_t MONERO_Wallet_getBytesReceived(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->getBytesReceived(); - DEBUG_END() -} -uint64_t MONERO_Wallet_getBytesSent(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->getBytesSent(); - DEBUG_END() -} - -bool MONERO_Wallet_getStateIsConnected() { - DEBUG_START() - return Monero::Wallet::getStateIsConnected(); - DEBUG_END() -} - -unsigned char* MONERO_Wallet_getSendToDevice() { - DEBUG_START() - return Monero::Wallet::getSendToDevice(); - DEBUG_END() -} - -size_t MONERO_Wallet_getSendToDeviceLength() { - DEBUG_START() - return Monero::Wallet::getSendToDeviceLength(); - DEBUG_END() -} - -unsigned char* MONERO_Wallet_getReceivedFromDevice() { - DEBUG_START() - return Monero::Wallet::getReceivedFromDevice(); - DEBUG_END() -} - -size_t MONERO_Wallet_getReceivedFromDeviceLength() { - DEBUG_START() - return Monero::Wallet::getReceivedFromDeviceLength(); - DEBUG_END() -} - -bool MONERO_Wallet_getWaitsForDeviceSend() { - DEBUG_START() - return Monero::Wallet::getWaitsForDeviceSend(); - DEBUG_END() -} - -bool MONERO_Wallet_getWaitsForDeviceReceive() { - DEBUG_START() - return Monero::Wallet::getWaitsForDeviceReceive(); - DEBUG_END() -} - -void MONERO_Wallet_setDeviceReceivedData(unsigned char* data, size_t len) { - DEBUG_START() - Monero::Wallet::setDeviceReceivedData(data, len); - DEBUG_END() -} - -void MONERO_Wallet_setDeviceSendData(unsigned char* data, size_t len) { - DEBUG_START() - Monero::Wallet::setDeviceSendData(data, len); - DEBUG_END() -} - -void MONERO_Wallet_setLedgerCallback(void (*sendToLedgerDevice)(unsigned char *command, unsigned int cmd_len)) { - DEBUG_START() - Monero::Wallet::setLedgerCallback(sendToLedgerDevice); - DEBUG_END() -} - -const char* MONERO_Wallet_serializeCacheToJson(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string result = wallet->serializeCacheToJson(); - return strdup(result.c_str()); - DEBUG_END() -} - -void* MONERO_WalletManager_createWallet(void* wm_ptr, const char* path, const char* password, const char* language, int networkType) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - Monero::Wallet *wallet = wm->createWallet( - std::string(path), - std::string(password), - std::string(language), - static_cast(networkType)); - return reinterpret_cast(wallet); - DEBUG_END() -} - -void* MONERO_WalletManager_openWallet(void* wm_ptr, const char* path, const char* password, int networkType) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - Monero::Wallet *wallet = wm->openWallet( - std::string(path), - std::string(password), - static_cast(networkType)); - return reinterpret_cast(wallet); - DEBUG_END() -} -void* MONERO_WalletManager_recoveryWallet(void* wm_ptr, const char* path, const char* password, const char* mnemonic, int networkType, uint64_t restoreHeight, uint64_t kdfRounds, const char* seedOffset) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - // (const std::string &path, const std::string &password, const std::string &mnemonic, - // NetworkType nettype = MAINNET, uint64_t restoreHeight = 0, uint64_t kdf_rounds = 1, - // const std::string &seed_offset = {}) - Monero::Wallet *wallet = wm->recoveryWallet( - std::string(path), - std::string(password), - std::string(mnemonic), - static_cast(networkType), - restoreHeight, - kdfRounds, - std::string(seedOffset)); - return reinterpret_cast(wallet); - DEBUG_END() -} -// virtual Wallet * createWalletFromKeys(const std::string &path, -// const std::string &password, -// const std::string &language, -// NetworkType nettype, -// uint64_t restoreHeight, -// const std::string &addressString, -// const std::string &viewKeyString, -// const std::string &spendKeyString = "", -// uint64_t kdf_rounds = 1) = 0; -void* MONERO_WalletManager_createWalletFromKeys(void* wm_ptr, const char* path, const char* password, const char* language, int nettype, uint64_t restoreHeight, const char* addressString, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - Monero::Wallet *wallet = wm->createWalletFromKeys( - std::string(path), - std::string(password), - std::string(language), - static_cast(nettype), - restoreHeight, - std::string(addressString), - std::string(viewKeyString), - std::string(spendKeyString)); - return reinterpret_cast(wallet); - DEBUG_END() -} - -void* MONERO_WalletManager_createWalletFromDevice(void* wm_ptr, const char* path, const char* password, int nettype, const char* deviceName, uint64_t restoreHeight, const char* subaddressLookahead, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - Monero::Wallet *wallet = wm->createWalletFromDevice(std::string(path), - std::string(password), - static_cast(nettype), - std::string(deviceName), - restoreHeight, - std::string(subaddressLookahead), - kdf_rounds); - return reinterpret_cast(wallet); - DEBUG_END() -} - -void* MONERO_WalletManager_createDeterministicWalletFromSpendKey(void* wm_ptr, const char* path, const char* password, - const char* language, int nettype, uint64_t restoreHeight, - const char* spendKeyString, uint64_t kdf_rounds) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - Monero::Wallet *wallet = wm->createDeterministicWalletFromSpendKey( - std::string(path), - std::string(password), - std::string(language), - static_cast(nettype), - restoreHeight, - std::string(spendKeyString), - kdf_rounds - ); - return reinterpret_cast(wallet); - DEBUG_END() -} - -void* MONERO_WalletManager_createWalletFromPolyseed(void* wm_ptr, const char* path, const char* password, - int nettype, const char* mnemonic, const char* passphrase, - bool newWallet, uint64_t restore_height, uint64_t kdf_rounds) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->createWalletFromPolyseed(std::string(path), - std::string(password), - static_cast(nettype), - std::string(mnemonic), - std::string(passphrase), - newWallet, - restore_height, - kdf_rounds); - DEBUG_END() -} - - -bool MONERO_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wm->closeWallet(wallet, store); - DEBUG_END() -} - -bool MONERO_WalletManager_walletExists(void* wm_ptr, const char* path) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->walletExists(std::string(path)); - DEBUG_END() -} - -// virtual bool verifyWalletPassword(const std::string &keys_file_name, const std::string &password, bool no_spend_key, uint64_t kdf_rounds = 1) const = 0; -bool MONERO_WalletManager_verifyWalletPassword(void* wm_ptr, const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->verifyWalletPassword(std::string(keys_file_name), std::string(password), no_spend_key, kdf_rounds); - DEBUG_END() -} - -// virtual bool queryWalletDevice(Wallet::Device& device_type, const std::string &keys_file_name, const std::string &password, uint64_t kdf_rounds = 1) const = 0; -int MONERO_WalletManager_queryWalletDevice(void* wm_ptr, const char* keys_file_name, const char* password, uint64_t kdf_rounds) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - Monero::Wallet::Device device_type; - wm->queryWalletDevice(device_type, std::string(keys_file_name), std::string(password), kdf_rounds); - return device_type; - DEBUG_END() -} - -// virtual std::vector findWallets(const std::string &path) = 0; -const char* MONERO_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return vectorToString(wm->findWallets(std::string(path)), std::string(separator)); - DEBUG_END() -} - - -const char* MONERO_WalletManager_errorString(void* wm_ptr) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - std::string str = wm->errorString(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -void MONERO_WalletManager_setDaemonAddress(void* wm_ptr, const char* address) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->setDaemonAddress(std::string(address)); - DEBUG_END() -} - -bool MONERO_WalletManager_setProxy(void* wm_ptr, const char* address) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->setProxy(std::string(address)); - DEBUG_END() -} - - -// virtual bool connected(uint32_t *version = NULL) = 0; -// virtual uint64_t blockchainHeight() = 0; -uint64_t MONERO_WalletManager_blockchainHeight(void* wm_ptr) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->blockchainHeight(); - DEBUG_END() -} -// virtual uint64_t blockchainTargetHeight() = 0; -uint64_t MONERO_WalletManager_blockchainTargetHeight(void* wm_ptr) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->blockchainTargetHeight(); - DEBUG_END() -} -// virtual uint64_t networkDifficulty() = 0; -uint64_t MONERO_WalletManager_networkDifficulty(void* wm_ptr) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->networkDifficulty(); - DEBUG_END() -} -// virtual double miningHashRate() = 0; -double MONERO_WalletManager_miningHashRate(void* wm_ptr) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->miningHashRate(); - DEBUG_END() -} -// virtual uint64_t blockTarget() = 0; -uint64_t MONERO_WalletManager_blockTarget(void* wm_ptr) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->blockTarget(); - DEBUG_END() -} -// virtual bool isMining() = 0; -bool MONERO_WalletManager_isMining(void* wm_ptr) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->isMining(); - DEBUG_END() -} -// virtual bool startMining(const std::string &address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true) = 0; -bool MONERO_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->startMining(std::string(address), threads, backgroundMining, ignoreBattery); - DEBUG_END() -} -// virtual bool stopMining() = 0; -bool MONERO_WalletManager_stopMining(void* wm_ptr, const char* address) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->stopMining(); - DEBUG_END() -} -// virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0; -const char* MONERO_WalletManager_resolveOpenAlias(void* wm_ptr, const char* address, bool dnssec_valid) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - std::string str = wm->resolveOpenAlias(std::string(address), dnssec_valid); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -// WalletManagerFactory - -void* MONERO_WalletManagerFactory_getWalletManager() { - DEBUG_START() - Monero::WalletManager *wm = Monero::WalletManagerFactory::getWalletManager(); - return reinterpret_cast(wm); - DEBUG_END() -} - -void MONERO_WalletManagerFactory_setLogLevel(int level) { - DEBUG_START() - return Monero::WalletManagerFactory::setLogLevel(level); - DEBUG_END() -} - -void MONERO_WalletManagerFactory_setLogCategories(const char* categories) { - DEBUG_START() - return Monero::WalletManagerFactory::setLogCategories(std::string(categories)); - DEBUG_END() -} - -// DEBUG functions - -// As it turns out we need a bit more functions to make sure that the library is working. -// 0) void -// 1) bool -// 2) int -// 3) uint64_t -// 4) void* -// 5) const char* - -void MONERO_DEBUG_test0() { - return; -} - -bool MONERO_DEBUG_test1(bool x) { - return x; -} - -int MONERO_DEBUG_test2(int x) { - return x; -} - -uint64_t MONERO_DEBUG_test3(uint64_t x) { - return x; -} - -void* MONERO_DEBUG_test4(uint64_t x) { - int *y = new int(x); - return reinterpret_cast(y); -} - -const char* MONERO_DEBUG_test5() { - const char *text = "This is a const char* text"; - return text; -} - -const char* MONERO_DEBUG_test5_std() { - std::string text("This is a std::string text"); - const char *text2 = "This is a text"; - return text2; -} - -bool MONERO_DEBUG_isPointerNull(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return (wallet != NULL); - DEBUG_END() -} - -// cake wallet world -// TODO(mrcyjanek): https://api.dart.dev/stable/3.3.3/dart-ffi/Pointer/fromFunction.html -// callback to dart should be possible..? I mean why not? But I need to -// wait for other implementation (Go preferably) to see if this approach -// will work as expected. -struct MONERO_cw_WalletListener; -struct MONERO_cw_WalletListener : Monero::WalletListener -{ - uint64_t m_height; - bool m_need_to_refresh; - bool m_new_transaction; - - MONERO_cw_WalletListener() - { - m_height = 0; - m_need_to_refresh = false; - m_new_transaction = false; - } - - void moneySpent(const std::string &txId, uint64_t amount) - { - m_new_transaction = true; - } - - void moneyReceived(const std::string &txId, uint64_t amount) - { - m_new_transaction = true; - } - - void unconfirmedMoneyReceived(const std::string &txId, uint64_t amount) - { - m_new_transaction = true; - } - - void newBlock(uint64_t height) - { - m_height = height; - } - - void updated() - { - m_new_transaction = true; - } - - void refreshed() - { - m_need_to_refresh = true; - } - - - void cw_resetNeedToRefresh() - { - m_need_to_refresh = false; - } - - bool cw_isNeedToRefresh() - { - return m_need_to_refresh; - } - - bool cw_isNewTransactionExist() - { - return m_new_transaction; - } - - void cw_resetIsNewTransactionExist() - { - m_new_transaction = false; - } - - uint64_t cw_height() - { - return m_height; - } -}; - -void* MONERO_cw_getWalletListener(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - MONERO_cw_WalletListener *listener = new MONERO_cw_WalletListener(); - wallet->setListener(listener); - return reinterpret_cast(listener); - DEBUG_END() -} - -void MONERO_cw_WalletListener_resetNeedToRefresh(void* cw_walletListener_ptr) { - DEBUG_START() - MONERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); - listener->cw_resetNeedToRefresh(); - DEBUG_END() -} - -bool MONERO_cw_WalletListener_isNeedToRefresh(void* cw_walletListener_ptr) { - DEBUG_START() - MONERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); - return listener->cw_isNeedToRefresh(); - DEBUG_END() -}; - -bool MONERO_cw_WalletListener_isNewTransactionExist(void* cw_walletListener_ptr) { - DEBUG_START() - MONERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); - return listener->cw_isNeedToRefresh(); - DEBUG_END() -}; - -void MONERO_cw_WalletListener_resetIsNewTransactionExist(void* cw_walletListener_ptr) { - DEBUG_START() - MONERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); - listener->cw_isNeedToRefresh(); - DEBUG_END() -}; - -uint64_t MONERO_cw_WalletListener_height(void* cw_walletListener_ptr) { - DEBUG_START() - MONERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); - return listener->cw_isNeedToRefresh(); - DEBUG_END() -}; - -const char* MONERO_checksum_wallet2_api_c_h() { - return MONERO_wallet2_api_c_h_sha256; -} -const char* MONERO_checksum_wallet2_api_c_cpp() { - return MONERO_wallet2_api_c_cpp_sha256; -} -const char* MONERO_checksum_wallet2_api_c_exp() { - return MONERO_wallet2_api_c_exp_sha256; -} -// i hate windows - -void MONERO_free(void* ptr) { - free(ptr); -} - -#ifdef __cplusplus -} -#endif diff --git a/monero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h b/monero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h deleted file mode 100644 index ff28d68..0000000 --- a/monero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h +++ /dev/null @@ -1,1042 +0,0 @@ -/* -#include - -#define LOG_TAG "[NDK]" -#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__) -#define LOGW(...) __android_log_print(ANDROID_LOG_WARN,LOG_TAG,__VA_ARGS__) -#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__) -*/ -#include -#include -#include -#include -#include "monero_checksum.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - -#ifdef __MINGW32__ - #define ADDAPI __declspec(dllexport) -#else - #define ADDAPI __attribute__((__visibility__("default"))) -#endif - -// namespace Monero { -// enum NetworkType : uint8_t { -// MAINNET = 0, -const int NetworkType_MAINNET = 0; -// TESTNET, -const int NetworkType_TESTNET = 1; -// STAGENET -const int NetworkType_STAGENET = 2; -// }; -// namespace Utils { -// bool isAddressLocal(const std::string &hostaddr); -// void onStartup(); -// } -// template -// class optional { -// public: -// optional(): set(false) {} -// optional(const T &t): t(t), set(true) {} -// const T &operator*() const { return t; } -// T &operator*() { return t; } -// operator bool() const { return set; } -// private: -// T t; -// bool set; -// }; - -// struct PendingTransaction -// { -// enum Status { -// Status_Ok, -const int PendingTransactionStatus_Ok = 0; -// Status_Error, -const int PendingTransactionStatus_Error = 1; -// Status_Critical -const int PendingTransactionStatus_Critical = 2; -// }; -// enum Priority { -// Priority_Default = 0, -const int Priority_Default = 0; -// Priority_Low = 1, -const int Priority_Low = 1; -// Priority_Medium = 2, -const int Priority_Medium = 2; -// Priority_High = 3, -const int Priority_High = 3; -// Priority_Last -const int Priority_Last = 4; -// }; -// virtual ~PendingTransaction() = 0; -// virtual int status() const = 0; -extern ADDAPI int MONERO_PendingTransaction_status(void* pendingTx_ptr); -// virtual std::string errorString() const = 0; -extern ADDAPI const char* MONERO_PendingTransaction_errorString(void* pendingTx_ptr); -// virtual bool commit(const std::string &filename = "", bool overwrite = false) = 0; -extern ADDAPI bool MONERO_PendingTransaction_commit(void* pendingTx_ptr, const char* filename, bool overwrite); -extern ADDAPI const char* MONERO_PendingTransaction_commitUR(void* pendingTx_ptr, int max_fragment_length); -// virtual uint64_t amount() const = 0; -extern ADDAPI uint64_t MONERO_PendingTransaction_amount(void* pendingTx_ptr); -// virtual uint64_t dust() const = 0; -extern ADDAPI uint64_t MONERO_PendingTransaction_dust(void* pendingTx_ptr); -// virtual uint64_t fee() const = 0; -extern ADDAPI uint64_t MONERO_PendingTransaction_fee(void* pendingTx_ptr); -// virtual std::vector txid() const = 0; -extern ADDAPI const char* MONERO_PendingTransaction_txid(void* pendingTx_ptr, const char* separator); -// virtual uint64_t txCount() const = 0; -extern ADDAPI uint64_t MONERO_PendingTransaction_txCount(void* pendingTx_ptr); -// virtual std::vector subaddrAccount() const = 0; -extern ADDAPI const char* MONERO_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator); -// virtual std::vector> subaddrIndices() const = 0; -extern ADDAPI const char* MONERO_PendingTransaction_subaddrIndices(void* pendingTx_ptr, const char* separator); -// virtual std::string multisigSignData() = 0; -extern ADDAPI const char* MONERO_PendingTransaction_multisigSignData(void* pendingTx_ptr); -// virtual void signMultisigTx() = 0; -extern ADDAPI void MONERO_PendingTransaction_signMultisigTx(void* pendingTx_ptr); -// virtual std::vector signersKeys() const = 0; -extern ADDAPI const char* MONERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator); -// virtual std::vector hex() const = 0; -extern ADDAPI const char* MONERO_PendingTransaction_hex(void* pendingTx_ptr, const char* separator); -// virtual std::vector txKey() const = 0; -// extern ADDAPI const char* MONERO_PendingTransaction_txHex(void* pendingTx_ptr, const char* separator); -// }; - -// struct UnsignedTransaction -// { -// enum Status { -// Status_Ok, -const int UnsignedTransactionStatus_Ok = 0; -// Status_Error, -const int UnsignedTransactionStatus_Error = 1; -// Status_Critical -const int UnsignedTransactionStatus_Critical = 2; -// }; -// virtual ~UnsignedTransaction() = 0; -// virtual int status() const = 0; -extern ADDAPI int MONERO_UnsignedTransaction_status(void* unsignedTx_ptr); -// virtual std::string errorString() const = 0; -extern ADDAPI const char* MONERO_UnsignedTransaction_errorString(void* unsignedTx_ptr); -// virtual std::vector amount() const = 0; -extern ADDAPI const char* MONERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator); -// virtual std::vector fee() const = 0; -extern ADDAPI const char* MONERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator); -// virtual std::vector mixin() const = 0; -extern ADDAPI const char* MONERO_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator); -// virtual std::string confirmationMessage() const = 0; -extern ADDAPI const char* MONERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr); -// virtual std::vector paymentId() const = 0; -extern ADDAPI const char* MONERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator); -// virtual std::vector recipientAddress() const = 0; -extern ADDAPI const char* MONERO_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator); -// virtual uint64_t minMixinCount() const = 0; -extern ADDAPI uint64_t MONERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr); -// virtual uint64_t txCount() const = 0; -extern ADDAPI uint64_t MONERO_UnsignedTransaction_txCount(void* unsignedTx_ptr); -// virtual bool sign(const std::string &signedFileName) = 0; -extern ADDAPI bool MONERO_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName); -extern ADDAPI const char* MONERO_UnsignedTransaction_signUR(void* unsignedTx_ptr, int max_fragment_length); -// }; -// struct TransactionInfo -// { -// enum Direction { -// Direction_In, -const int TransactionInfoDirection_In = 0; -// Direction_Out -const int TransactionInfoDirection_Out = 1; -// }; -// struct Transfer { -// Transfer(uint64_t _amount, const std::string &address); -// const uint64_t amount; -// const std::string address; -// }; -// virtual ~TransactionInfo() = 0; -// virtual int direction() const = 0; -extern ADDAPI int MONERO_TransactionInfo_direction(void* txInfo_ptr); -// virtual bool isPending() const = 0; -extern ADDAPI bool MONERO_TransactionInfo_isPending(void* txInfo_ptr); -// virtual bool isFailed() const = 0; -extern ADDAPI bool MONERO_TransactionInfo_isFailed(void* txInfo_ptr); -// virtual bool isCoinbase() const = 0; -extern ADDAPI bool MONERO_TransactionInfo_isCoinbase(void* txInfo_ptr); -// virtual uint64_t amount() const = 0; -extern ADDAPI uint64_t MONERO_TransactionInfo_amount(void* txInfo_ptr); -// virtual uint64_t fee() const = 0; -extern ADDAPI uint64_t MONERO_TransactionInfo_fee(void* txInfo_ptr); -// virtual uint64_t blockHeight() const = 0; -extern ADDAPI uint64_t MONERO_TransactionInfo_blockHeight(void* txInfo_ptr); -// virtual std::string description() const = 0; -extern ADDAPI const char* MONERO_TransactionInfo_description(void* txInfo_ptr); -// virtual std::set subaddrIndex() const = 0; -extern ADDAPI const char* MONERO_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator); -// virtual uint32_t subaddrAccount() const = 0; -extern ADDAPI uint32_t MONERO_TransactionInfo_subaddrAccount(void* txInfo_ptr); -// virtual std::string label() const = 0; -extern ADDAPI const char* MONERO_TransactionInfo_label(void* txInfo_ptr); -// virtual uint64_t confirmations() const = 0; -extern ADDAPI uint64_t MONERO_TransactionInfo_confirmations(void* txInfo_ptr); -// virtual uint64_t unlockTime() const = 0; -extern ADDAPI uint64_t MONERO_TransactionInfo_unlockTime(void* txInfo_ptr); -// virtual std::string hash() const = 0; -extern ADDAPI const char* MONERO_TransactionInfo_hash(void* txInfo_ptr); -// virtual std::time_t timestamp() const = 0; -extern ADDAPI uint64_t MONERO_TransactionInfo_timestamp(void* txInfo_ptr); -// virtual std::string paymentId() const = 0; -extern ADDAPI const char* MONERO_TransactionInfo_paymentId(void* txInfo_ptr); -// virtual const std::vector & transfers() const = 0; -extern ADDAPI int MONERO_TransactionInfo_transfers_count(void* txInfo_ptr); -extern ADDAPI uint64_t MONERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index); -extern ADDAPI const char* MONERO_TransactionInfo_transfers_address(void* txInfo_ptr, int address); -// }; -// struct TransactionHistory -// { -// virtual ~TransactionHistory() = 0; -// virtual int count() const = 0; -extern ADDAPI int MONERO_TransactionHistory_count(void* txHistory_ptr); -// virtual TransactionInfo * transaction(int index) const = 0; -extern ADDAPI void* MONERO_TransactionHistory_transaction(void* txHistory_ptr, int index); -// virtual TransactionInfo * transaction(const std::string &id) const = 0; -extern ADDAPI void* MONERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id); -// virtual std::vector getAll() const = 0; -// virtual void refresh() = 0; -extern ADDAPI void MONERO_TransactionHistory_refresh(void* txHistory_ptr); -// virtual void setTxNote(const std::string &txid, const std::string ¬e) = 0; -extern ADDAPI void MONERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note); -// }; -// struct AddressBookRow { -// public: -// AddressBookRow(std::size_t _rowId, const std::string &_address, const std::string &_paymentId, const std::string &_description): -// m_rowId(_rowId), -// m_address(_address), -// m_paymentId(_paymentId), -// m_description(_description) {} - -// private: -// std::size_t m_rowId; -// std::string m_address; -// std::string m_paymentId; -// std::string m_description; -// public: -// std::string extra; -extern ADDAPI const char* MONERO_AddressBookRow_extra(void* addressBookRow_ptr); -// std::string getAddress() const {return m_address;} -extern ADDAPI const char* MONERO_AddressBookRow_getAddress(void* addressBookRow_ptr); -// std::string getDescription() const {return m_description;} -extern ADDAPI const char* MONERO_AddressBookRow_getDescription(void* addressBookRow_ptr); -// std::string getPaymentId() const {return m_paymentId;} -extern ADDAPI const char* MONERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr); -// std::size_t getRowId() const {return m_rowId;} -extern ADDAPI size_t MONERO_AddressBookRow_getRowId(void* addressBookRow_ptr); -// }; -// struct AddressBook -// { -// enum ErrorCode { -// Status_Ok, -const int AddressBookErrorCodeStatus_Ok = 0; -// General_Error, -const int AddressBookErrorCodeGeneral_Error = 1; -// Invalid_Address, -const int AddressBookErrorCodeInvalid_Address = 2; -// Invalid_Payment_Id -const int AddressBookErrorCodeInvalidPaymentId = 3; -// }; -// virtual ~AddressBook() = 0; -// virtual std::vector getAll() const = 0; -extern ADDAPI int MONERO_AddressBook_getAll_size(void* addressBook_ptr); -extern ADDAPI void* MONERO_AddressBook_getAll_byIndex(void* addressBook_ptr, int index); -// virtual bool addRow(const std::string &dst_addr , const std::string &payment_id, const std::string &description) = 0; -extern ADDAPI bool MONERO_AddressBook_addRow(void* addressBook_ptr, const char* dst_addr , const char* payment_id, const char* description); -// virtual bool deleteRow(std::size_t rowId) = 0; -extern ADDAPI bool MONERO_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId); -// virtual bool setDescription(std::size_t index, const std::string &description) = 0; -extern ADDAPI bool MONERO_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description); -// virtual void refresh() = 0; -extern ADDAPI void MONERO_AddressBook_refresh(void* addressBook_ptr); -// virtual std::string errorString() const = 0; -extern ADDAPI const char* MONERO_AddressBook_errorString(void* addressBook_ptr); -// virtual int errorCode() const = 0; -extern ADDAPI int MONERO_AddressBook_errorCode(void* addressBook_ptr); -// virtual int lookupPaymentID(const std::string &payment_id) const = 0; -extern ADDAPI int MONERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id); -// }; -// struct CoinsInfo -// { -// virtual ~CoinsInfo() = 0; -// virtual uint64_t blockHeight() const = 0; -extern ADDAPI uint64_t MONERO_CoinsInfo_blockHeight(void* coinsInfo_ptr); -// virtual std::string hash() const = 0; -extern ADDAPI const char* MONERO_CoinsInfo_hash(void* coinsInfo_ptr); -// virtual size_t internalOutputIndex() const = 0; -extern ADDAPI size_t MONERO_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr); -// virtual uint64_t globalOutputIndex() const = 0; -extern ADDAPI uint64_t MONERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr); -// virtual bool spent() const = 0; -extern ADDAPI bool MONERO_CoinsInfo_spent(void* coinsInfo_ptr); -// virtual bool frozen() const = 0; -extern ADDAPI bool MONERO_CoinsInfo_frozen(void* coinsInfo_ptr); -// virtual uint64_t spentHeight() const = 0; -extern ADDAPI uint64_t MONERO_CoinsInfo_spentHeight(void* coinsInfo_ptr); -// virtual uint64_t amount() const = 0; -extern ADDAPI uint64_t MONERO_CoinsInfo_amount(void* coinsInfo_ptr); -// virtual bool rct() const = 0; -extern ADDAPI bool MONERO_CoinsInfo_rct(void* coinsInfo_ptr); -// virtual bool keyImageKnown() const = 0; -extern ADDAPI bool MONERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr); -// virtual size_t pkIndex() const = 0; -extern ADDAPI size_t MONERO_CoinsInfo_pkIndex(void* coinsInfo_ptr); -// virtual uint32_t subaddrIndex() const = 0; -extern ADDAPI uint32_t MONERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr); -// virtual uint32_t subaddrAccount() const = 0; -extern ADDAPI uint32_t MONERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr); -// virtual std::string address() const = 0; -extern ADDAPI const char* MONERO_CoinsInfo_address(void* coinsInfo_ptr); -// virtual std::string addressLabel() const = 0; -extern ADDAPI const char* MONERO_CoinsInfo_addressLabel(void* coinsInfo_ptr); -// virtual std::string keyImage() const = 0; -extern ADDAPI const char* MONERO_CoinsInfo_keyImage(void* coinsInfo_ptr); -// virtual uint64_t unlockTime() const = 0; -extern ADDAPI uint64_t MONERO_CoinsInfo_unlockTime(void* coinsInfo_ptr); -// virtual bool unlocked() const = 0; -extern ADDAPI bool MONERO_CoinsInfo_unlocked(void* coinsInfo_ptr); -// virtual std::string pubKey() const = 0; -extern ADDAPI const char* MONERO_CoinsInfo_pubKey(void* coinsInfo_ptr); -// virtual bool coinbase() const = 0; -extern ADDAPI bool MONERO_CoinsInfo_coinbase(void* coinsInfo_ptr); -// virtual std::string description() const = 0; -extern ADDAPI const char* MONERO_CoinsInfo_description(void* coinsInfo_ptr); -// }; -// struct Coins -// { -// virtual ~Coins() = 0; -// virtual int count() const = 0; -extern ADDAPI int MONERO_Coins_count(void* coins_ptr); -// virtual CoinsInfo * coin(int index) const = 0; -extern ADDAPI void* MONERO_Coins_coin(void* coins_ptr, int index); -// virtual std::vector getAll() const = 0; -extern ADDAPI int MONERO_Coins_getAll_size(void* coins_ptr); -extern ADDAPI void* MONERO_Coins_getAll_byIndex(void* coins_ptr, int index); -// virtual void refresh() = 0; -extern ADDAPI void MONERO_Coins_refresh(void* coins_ptr); -// virtual void setFrozen(std::string public_key) = 0; -extern ADDAPI void MONERO_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key); -// virtual void setFrozen(int index) = 0; -extern ADDAPI void MONERO_Coins_setFrozen(void* coins_ptr, int index); -// virtual void thaw(int index) = 0; -extern ADDAPI void MONERO_Coins_thaw(void* coins_ptr, int index); -// virtual void thaw(std::string public_key) = 0; -extern ADDAPI void MONERO_Coins_thawByPublicKey(void* coins_ptr, const char* public_key); -// virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0; -extern ADDAPI bool MONERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight); -// virtual void setDescription(const std::string &public_key, const std::string &description) = 0; -extern ADDAPI void MONERO_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description); -// }; -// struct SubaddressRow { -// public: -// SubaddressRow(std::size_t _rowId, const std::string &_address, const std::string &_label): -// m_rowId(_rowId), -// m_address(_address), -// m_label(_label) {} - -// private: -// std::size_t m_rowId; -// std::string m_address; -// std::string m_label; -// public: -// std::string extra; -extern ADDAPI const char* MONERO_SubaddressRow_extra(void* subaddressRow_ptr); -// std::string getAddress() const {return m_address;} -extern ADDAPI const char* MONERO_SubaddressRow_getAddress(void* subaddressRow_ptr); -// std::string getLabel() const {return m_label;} -extern ADDAPI const char* MONERO_SubaddressRow_getLabel(void* subaddressRow_ptr); -// std::size_t getRowId() const {return m_rowId;} -extern ADDAPI size_t MONERO_SubaddressRow_getRowId(void* subaddressRow_ptr); -// }; - -// struct Subaddress -// { -// virtual ~Subaddress() = 0; -// virtual std::vector getAll() const = 0; -extern ADDAPI int MONERO_Subaddress_getAll_size(void* subaddress_ptr); -extern ADDAPI void* MONERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index); -// virtual void addRow(uint32_t accountIndex, const std::string &label) = 0; -extern ADDAPI void MONERO_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label); -// virtual void setLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0; -extern ADDAPI void MONERO_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label); -// virtual void refresh(uint32_t accountIndex) = 0; -extern ADDAPI void MONERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex); -// }; - -// struct SubaddressAccountRow { -// public: -// SubaddressAccountRow(std::size_t _rowId, const std::string &_address, const std::string &_label, const std::string &_balance, const std::string &_unlockedBalance): -// m_rowId(_rowId), -// m_address(_address), -// m_label(_label), -// m_balance(_balance), -// m_unlockedBalance(_unlockedBalance) {} - -// private: -// std::size_t m_rowId; -// std::string m_address; -// std::string m_label; -// std::string m_balance; -// std::string m_unlockedBalance; -// public: -// std::string extra; -extern ADDAPI const char* MONERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr); -// std::string getAddress() const {return m_address;} -extern ADDAPI const char* MONERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr); -// std::string getLabel() const {return m_label;} -extern ADDAPI const char* MONERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr); -// std::string getBalance() const {return m_balance;} -extern ADDAPI const char* MONERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr); -// std::string getUnlockedBalance() const {return m_unlockedBalance;} -extern ADDAPI const char* MONERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr); -// std::size_t getRowId() const {return m_rowId;} -extern ADDAPI size_t MONERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr); -// }; - -// struct SubaddressAccount -// { -// virtual ~SubaddressAccount() = 0; -// virtual std::vector getAll() const = 0; -extern ADDAPI int MONERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr); -extern ADDAPI void* MONERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index); -// virtual void addRow(const std::string &label) = 0; -extern ADDAPI void MONERO_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label); -// virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0; -extern ADDAPI void MONERO_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label); -// virtual void refresh() = 0; -extern ADDAPI void MONERO_SubaddressAccount_refresh(void* subaddressAccount_ptr); -// }; - -// struct MultisigState { -// MultisigState() : isMultisig(false), isReady(false), threshold(0), total(0) {} - -// bool isMultisig; -extern ADDAPI bool MONERO_MultisigState_isMultisig(void* multisigState_ptr); -// bool isReady; -extern ADDAPI bool MONERO_MultisigState_isReady(void* multisigState_ptr); -// uint32_t threshold; -extern ADDAPI uint32_t MONERO_MultisigState_threshold(void* multisigState_ptr); -// uint32_t total; -extern ADDAPI uint32_t MONERO_MultisigState_total(void* multisigState_ptr); -// }; - - -// struct DeviceProgress { -// DeviceProgress(): m_progress(0), m_indeterminate(false) {} -// DeviceProgress(double progress, bool indeterminate=false): m_progress(progress), m_indeterminate(indeterminate) {} - -// virtual double progress() const { return m_progress; } -extern ADDAPI bool MONERO_DeviceProgress_progress(void* deviceProgress_ptr); -// virtual bool indeterminate() const { return m_indeterminate; } -extern ADDAPI bool MONERO_DeviceProgress_indeterminate(void* deviceProgress_ptr); - -// protected: -// double m_progress; -// bool m_indeterminate; -// }; - -// struct Wallet; -// struct WalletListener -// { -// virtual ~WalletListener() = 0; -// virtual void moneySpent(const std::string &txId, uint64_t amount) = 0; -// virtual void moneyReceived(const std::string &txId, uint64_t amount) = 0; -// virtual void unconfirmedMoneyReceived(const std::string &txId, uint64_t amount) = 0; -// virtual void newBlock(uint64_t height) = 0; -// virtual void updated() = 0; -// virtual void refreshed() = 0; -// virtual void onDeviceButtonRequest(uint64_t code) { (void)code; } -// virtual void onDeviceButtonPressed() { } -// virtual optional onDevicePinRequest() { -// throw std::runtime_error("Not supported"); -// } -// virtual optional onDevicePassphraseRequest(bool & on_device) { -// on_device = true; -// return optional(); -// } -// virtual void onDeviceProgress(const DeviceProgress & event) { (void)event; }; -// virtual void onSetWallet(Wallet * wallet) { (void)wallet; }; -// }; -// struct Wallet -// { -// enum Device { -// Device_Software = 0, -const int WalletDevice_Software = 0; -// Device_Ledger = 1, -const int WalletDevice_Ledger = 1; -// Device_Trezor = 2 -const int WalletDevice_Trezor = 2; -// }; -// enum Status { -// Status_Ok, -const int WalletStatus_Ok = 0; -// Status_Error, -const int WalletStatus_Error = 1; -// Status_Critical -const int WalletStatus_Critical = 2; -// }; -// enum ConnectionStatus { -// ConnectionStatus_Disconnected, -const int WalletConnectionStatus_Disconnected = 0; -// ConnectionStatus_Connected, -const int WalletConnectionStatus_Connected = 1; -// ConnectionStatus_WrongVersion -const int WalletConnectionStatus_WrongVersion = 2; -// }; -// enum BackgroundSyncType { -// BackgroundSync_Off = 0, -const int WalletBackgroundSync_Off = 0; -// BackgroundSync_ReusePassword = 1, -const int WalletBackgroundSync_ReusePassword = 1; -// BackgroundSync_CustomPassword = 2 -const int BackgroundSync_CustomPassword = 2; -// }; -// virtual ~Wallet() = 0; -// virtual std::string seed(const std::string& seed_offset = "") const = 0; -extern ADDAPI const char* MONERO_Wallet_seed(void* wallet_ptr, const char* seed_offset); -// virtual std::string getSeedLanguage() const = 0; -extern ADDAPI const char* MONERO_Wallet_getSeedLanguage(void* wallet_ptr); -// virtual void setSeedLanguage(const std::string &arg) = 0; -extern ADDAPI void MONERO_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg); -// virtual int status() const = 0; -extern ADDAPI int MONERO_Wallet_status(void* wallet_ptr); -// virtual std::string errorString() const = 0; -extern ADDAPI const char* MONERO_Wallet_errorString(void* wallet_ptr); -// virtual void statusWithErrorString(int& status, std::string& errorString) const = 0; -// virtual bool setPassword(const std::string &password) = 0; -extern ADDAPI bool MONERO_Wallet_setPassword(void* wallet_ptr, const char* password); -// virtual const std::string& getPassword() const = 0; -extern ADDAPI const char* MONERO_Wallet_getPassword(void* wallet_ptr); -// virtual bool setDevicePin(const std::string &pin) { (void)pin; return false; }; -extern ADDAPI bool MONERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin); -// virtual bool setDevicePassphrase(const std::string &passphrase) { (void)passphrase; return false; }; -extern ADDAPI bool MONERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase); -// virtual std::string address(uint32_t accountIndex = 0, uint32_t addressIndex = 0) const = 0; -extern ADDAPI const char* MONERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex); -// std::string mainAddress() const { return address(0, 0); } -// virtual std::string path() const = 0; -extern ADDAPI const char* MONERO_Wallet_path(void* wallet_ptr); -// virtual NetworkType nettype() const = 0; -extern ADDAPI int MONERO_Wallet_nettype(void* wallet_ptr); -// bool mainnet() const { return nettype() == MAINNET; } -// bool testnet() const { return nettype() == TESTNET; } -// bool stagenet() const { return nettype() == STAGENET; } -// virtual void hardForkInfo(uint8_t &version, uint64_t &earliest_height) const = 0; -// virtual bool useForkRules(uint8_t version, int64_t early_blocks) const = 0; -extern ADDAPI uint8_t MONERO_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks); -// virtual std::string integratedAddress(const std::string &payment_id) const = 0; -extern ADDAPI const char* MONERO_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id); -// virtual std::string secretViewKey() const = 0; -extern ADDAPI const char* MONERO_Wallet_secretViewKey(void* wallet_ptr); -// virtual std::string publicViewKey() const = 0; -extern ADDAPI const char* MONERO_Wallet_publicViewKey(void* wallet_ptr); -// virtual std::string secretSpendKey() const = 0; -extern ADDAPI const char* MONERO_Wallet_secretSpendKey(void* wallet_ptr); -// virtual std::string publicSpendKey() const = 0; -extern ADDAPI const char* MONERO_Wallet_publicSpendKey(void* wallet_ptr); -// virtual std::string publicMultisigSignerKey() const = 0; -extern ADDAPI const char* MONERO_Wallet_publicMultisigSignerKey(void* wallet_ptr); -// virtual void stop() = 0; -extern ADDAPI void MONERO_Wallet_stop(void* wallet_ptr); -// virtual bool store(const std::string &path) = 0; -extern ADDAPI bool MONERO_Wallet_store(void* wallet_ptr, const char* path); -// virtual std::string filename() const = 0; -extern ADDAPI const char* MONERO_Wallet_filename(void* wallet_ptr); -// virtual std::string keysFilename() const = 0; -extern ADDAPI const char* MONERO_Wallet_keysFilename(void* wallet_ptr); -// virtual bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit = 0, const std::string &daemon_username = "", const std::string &daemon_password = "", bool use_ssl = false, bool lightWallet = false, const std::string &proxy_address = "") = 0; -extern ADDAPI bool MONERO_Wallet_init(void* wallet_ptr, const char* daemon_address, uint64_t upper_transaction_size_limit, const char* daemon_username, const char* daemon_password, bool use_ssl, bool lightWallet, const char* proxy_address); -// virtual bool createWatchOnly(const std::string &path, const std::string &password, const std::string &language) const = 0; -extern ADDAPI bool MONERO_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language); -// virtual void setRefreshFromBlockHeight(uint64_t refresh_from_block_height) = 0; -extern ADDAPI void MONERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height); -// virtual uint64_t getRefreshFromBlockHeight() const = 0; -extern ADDAPI uint64_t MONERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr); -// virtual void setRecoveringFromSeed(bool recoveringFromSeed) = 0; -extern ADDAPI void MONERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed); -// virtual void setRecoveringFromDevice(bool recoveringFromDevice) = 0; -extern ADDAPI void MONERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice); -// virtual void setSubaddressLookahead(uint32_t major, uint32_t minor) = 0; -extern ADDAPI void MONERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor); -// virtual bool connectToDaemon() = 0; -extern ADDAPI bool MONERO_Wallet_connectToDaemon(void* wallet_ptr); -// virtual ConnectionStatus connected() const = 0; -extern ADDAPI int MONERO_Wallet_connected(void* wallet_ptr); -// virtual void setTrustedDaemon(bool arg) = 0; -extern ADDAPI void MONERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg); -// virtual bool trustedDaemon() const = 0; -extern ADDAPI bool MONERO_Wallet_trustedDaemon(void* wallet_ptr); -// virtual bool setProxy(const std::string &address) = 0; -extern ADDAPI bool MONERO_Wallet_setProxy(void* wallet_ptr, const char* address); -// virtual uint64_t balance(uint32_t accountIndex = 0) const = 0; -extern ADDAPI uint64_t MONERO_Wallet_balance(void* wallet_ptr, uint32_t accountIndex); -// uint64_t balanceAll() const { -// uint64_t result = 0; -// for (uint32_t i = 0; i < numSubaddressAccounts(); ++i) -// result += balance(i); -// return result; -// } -// virtual uint64_t unlockedBalance(uint32_t accountIndex = 0) const = 0; -extern ADDAPI uint64_t MONERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex); -// uint64_t unlockedBalanceAll() const { -// uint64_t result = 0; -// for (uint32_t i = 0; i < numSubaddressAccounts(); ++i) -// result += unlockedBalance(i); -// return result; -// } -// virtual bool watchOnly() const = 0; -// virtual uint64_t viewOnlyBalance(uint32_t accountIndex, const std::vector &key_images = {}) const = 0; -extern ADDAPI uint64_t MONERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex); -extern ADDAPI bool MONERO_Wallet_watchOnly(void* wallet_ptr); -// virtual bool isDeterministic() const = 0; -extern ADDAPI bool MONERO_Wallet_isDeterministic(void* wallet_ptr); -// virtual uint64_t blockChainHeight() const = 0; -extern ADDAPI uint64_t MONERO_Wallet_blockChainHeight(void* wallet_ptr); -// virtual uint64_t approximateBlockChainHeight() const = 0; -extern ADDAPI uint64_t MONERO_Wallet_approximateBlockChainHeight(void* wallet_ptr); -// virtual uint64_t estimateBlockChainHeight() const = 0; -extern ADDAPI uint64_t MONERO_Wallet_estimateBlockChainHeight(void* wallet_ptr); -// virtual uint64_t daemonBlockChainHeight() const = 0; -extern ADDAPI uint64_t MONERO_Wallet_daemonBlockChainHeight(void* wallet_ptr); -// virtual uint64_t daemonBlockChainTargetHeight() const = 0; -extern ADDAPI uint64_t MONERO_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr); -// virtual bool synchronized() const = 0; -extern ADDAPI bool MONERO_Wallet_synchronized(void* wallet_ptr); -// static std::string displayAmount(uint64_t amount); -extern ADDAPI const char* MONERO_Wallet_displayAmount(uint64_t amount); -// static uint64_t amountFromString(const std::string &amount); -extern ADDAPI uint64_t MONERO_Wallet_amountFromString(const char* amount); -// static uint64_t amountFromDouble(double amount); -extern ADDAPI uint64_t MONERO_Wallet_amountFromDouble(double amount); -// static std::string genPaymentId(); -extern ADDAPI const char* MONERO_Wallet_genPaymentId(); -// static bool paymentIdValid(const std::string &paiment_id); -extern ADDAPI bool MONERO_Wallet_paymentIdValid(const char* paiment_id); -// static bool addressValid(const std::string &str, NetworkType nettype); -extern ADDAPI bool MONERO_Wallet_addressValid(const char* str, int nettype); -// static bool addressValid(const std::string &str, bool testnet) // deprecated -// { -// return addressValid(str, testnet ? TESTNET : MAINNET); -// } -extern ADDAPI bool MONERO_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype); -extern ADDAPI const char* MONERO_Wallet_keyValid_error(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype); -// static bool keyValid(const std::string &secret_key_string, const std::string &address_string, bool isViewKey, NetworkType nettype, std::string &error); -// static bool keyValid(const std::string &secret_key_string, const std::string &address_string, bool isViewKey, bool testnet, std::string &error) // deprecated -// { -// return keyValid(secret_key_string, address_string, isViewKey, testnet ? TESTNET : MAINNET, error); -// } -// static std::string paymentIdFromAddress(const std::string &str, NetworkType nettype); -extern ADDAPI const char* MONERO_Wallet_paymentIdFromAddress(const char* strarg, int nettype); -// static std::string paymentIdFromAddress(const std::string &str, bool testnet) // deprecated -// { -// return paymentIdFromAddress(str, testnet ? TESTNET : MAINNET); -// } -// static uint64_t maximumAllowedAmount(); -extern ADDAPI uint64_t MONERO_Wallet_maximumAllowedAmount(); -// static void init(const char *argv0, const char *default_log_base_name) { init(argv0, default_log_base_name, "", true); } -// static void init(const char *argv0, const char *default_log_base_name, const std::string &log_path, bool console); -extern ADDAPI void MONERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console); -// static void debug(const std::string &category, const std::string &str); -// static void info(const std::string &category, const std::string &str); -// static void warning(const std::string &category, const std::string &str); -// static void error(const std::string &category, const std::string &str); -// virtual void startRefresh() = 0; -// virtual bool getPolyseed(std::string &seed, std::string &passphrase) const = 0; -extern ADDAPI const char* MONERO_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase); -// static bool createPolyseed(std::string &seed_words, std::string &err, const std::string &language = "English"); -extern ADDAPI const char* MONERO_Wallet_createPolyseed(const char* language); -extern ADDAPI void MONERO_Wallet_startRefresh(void* wallet_ptr); -// virtual void pauseRefresh() = 0; -extern ADDAPI void MONERO_Wallet_pauseRefresh(void* wallet_ptr); -// virtual bool refresh() = 0; -extern ADDAPI bool MONERO_Wallet_refresh(void* wallet_ptr); -// virtual void refreshAsync() = 0; -extern ADDAPI void MONERO_Wallet_refreshAsync(void* wallet_ptr); -// virtual bool rescanBlockchain() = 0; -extern ADDAPI bool MONERO_Wallet_rescanBlockchain(void* wallet_ptr); -// virtual void rescanBlockchainAsync() = 0; -extern ADDAPI void MONERO_Wallet_rescanBlockchainAsync(void* wallet_ptr); -// virtual void setAutoRefreshInterval(int millis) = 0; -extern ADDAPI void MONERO_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis); -// virtual int autoRefreshInterval() const = 0; -extern ADDAPI int MONERO_Wallet_autoRefreshInterval(void* wallet_ptr); -// virtual void addSubaddressAccount(const std::string& label) = 0; -extern ADDAPI void MONERO_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label); -// virtual size_t numSubaddressAccounts() const = 0; -extern ADDAPI size_t MONERO_Wallet_numSubaddressAccounts(void* wallet_ptr); -// virtual size_t numSubaddresses(uint32_t accountIndex) const = 0; -extern ADDAPI size_t MONERO_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex); -// virtual void addSubaddress(uint32_t accountIndex, const std::string& label) = 0; -extern ADDAPI void MONERO_Wallet_addSubaddress(void* wallet_ptr, uint32_t accountIndex, const char* label); -// virtual std::string getSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex) const = 0; -extern ADDAPI const char* MONERO_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex); -// virtual void setSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0; -extern ADDAPI void MONERO_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label); -// virtual MultisigState multisig() const = 0; -extern ADDAPI void* MONERO_Wallet_multisig(void* wallet_ptr); -// virtual std::string getMultisigInfo() const = 0; -extern ADDAPI const char* MONERO_Wallet_getMultisigInfo(void* wallet_ptr); -// virtual std::string makeMultisig(const std::vector& info, uint32_t threshold) = 0; -extern ADDAPI const char* MONERO_Wallet_makeMultisig(void* wallet_ptr, const char* info, const char* info_separator, uint32_t threshold); -// virtual std::string exchangeMultisigKeys(const std::vector &info, const bool force_update_use_with_caution) = 0; -extern ADDAPI const char* MONERO_Wallet_exchangeMultisigKeys(void* wallet_ptr, const char* info, const char* info_separator, bool force_update_use_with_caution); -// virtual bool exportMultisigImages(std::string& images) = 0; -extern ADDAPI const char* MONERO_Wallet_exportMultisigImages(void* wallet_ptr, const char* separator); -// virtual size_t importMultisigImages(const std::vector& images) = 0; -extern ADDAPI size_t MONERO_Wallet_importMultisigImages(void* wallet_ptr, const char* info, const char* info_separator); -// virtual bool hasMultisigPartialKeyImages() const = 0; -extern ADDAPI size_t MONERO_Wallet_hasMultisigPartialKeyImages(void* wallet_ptr); -// virtual PendingTransaction* restoreMultisigTransaction(const std::string& signData) = 0; -extern ADDAPI void* MONERO_Wallet_restoreMultisigTransaction(void* wallet_ptr, const char* signData); -// virtual PendingTransaction * createTransactionMultDest(const std::vector &dst_addr, const std::string &payment_id, -// optional> amount, uint32_t mixin_count, -// PendingTransaction::Priority = PendingTransaction::Priority_Low, -// uint32_t subaddr_account = 0, -// std::set subaddr_indices = {}) = 0; -extern ADDAPI void* MONERO_Wallet_createTransactionMultDest(void* wallet_ptr, const char* dst_addr_list, const char* dst_addr_list_separator, const char* payment_id, - bool amount_sweep_all, const char* amount_list, const char* amount_list_separator, uint32_t mixin_count, - int pendingTransactionPriority, - uint32_t subaddr_account, - const char* preferredInputs, const char* preferredInputs_separator); -// virtual PendingTransaction * createTransaction(const std::string &dst_addr, const std::string &payment_id, -// optional amount, uint32_t mixin_count, -// PendingTransaction::Priority = PendingTransaction::Priority_Low, -// uint32_t subaddr_account = 0, -// std::set subaddr_indices = {}, -// const std::set &preferred_inputs = {) = 0; -extern ADDAPI void* MONERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, - uint64_t amount, uint32_t mixin_count, - int pendingTransactionPriority, - uint32_t subaddr_account, - const char* preferredInputs, const char* separator); -// virtual PendingTransaction * createSweepUnmixableTransaction() = 0; -// virtual UnsignedTransaction * loadUnsignedTx(const std::string &unsigned_filename) = 0; -extern ADDAPI void* MONERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* unsigned_filename); -extern ADDAPI void* MONERO_Wallet_loadUnsignedTxUR(void* wallet_ptr, const char* input); -// virtual bool submitTransaction(const std::string &fileName) = 0; -extern ADDAPI bool MONERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName); -extern ADDAPI bool MONERO_Wallet_submitTransactionUR(void* wallet_ptr, const char* input); -// virtual void disposeTransaction(PendingTransaction * t) = 0; -// virtual uint64_t estimateTransactionFee(const std::vector> &destinations, -// PendingTransaction::Priority priority) const = 0; -// virtual bool hasUnknownKeyImages() const = 0; -extern ADDAPI bool MONERO_Wallet_hasUnknownKeyImages(void* wallet_ptr); -// virtual bool exportKeyImages(const std::string &filename, bool all = false) = 0; -extern ADDAPI bool MONERO_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all); -extern ADDAPI const char* MONERO_Wallet_exportKeyImagesUR(void* wallet_ptr, size_t max_fragment_length, bool all) ; -// virtual bool importKeyImages(const std::string &filename) = 0; -extern ADDAPI bool MONERO_Wallet_importKeyImages(void* wallet_ptr, const char* filename); -extern ADDAPI bool MONERO_Wallet_importKeyImagesUR(void* wallet_ptr, const char* input); -// virtual bool exportOutputs(const std::string &filename, bool all = false) = 0; -extern ADDAPI bool MONERO_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool all); -extern ADDAPI const char* MONERO_Wallet_exportOutputsUR(void* wallet_ptr, size_t max_fragment_length, bool all); -// virtual bool importOutputs(const std::string &filename) = 0; -extern ADDAPI bool MONERO_Wallet_importOutputs(void* wallet_ptr, const char* filename); -extern ADDAPI bool MONERO_Wallet_importOutputsUR(void* wallet_ptr, const char* input); -// virtual bool scanTransactions(const std::vector &txids) = 0; -// virtual bool setupBackgroundSync(const BackgroundSyncType background_sync_type, const std::string &wallet_password, const optional &background_cache_password) = 0; -extern ADDAPI bool MONERO_Wallet_setupBackgroundSync(void* wallet_ptr, int background_sync_type, const char* wallet_password, const char* background_cache_password); -// virtual BackgroundSyncType getBackgroundSyncType() const = 0; -extern ADDAPI int MONERO_Wallet_getBackgroundSyncType(void* wallet_ptr); -// virtual bool startBackgroundSync() = 0; -extern ADDAPI bool MONERO_Wallet_startBackgroundSync(void* wallet_ptr); -// virtual bool stopBackgroundSync(const std::string &wallet_password) = 0; -extern ADDAPI bool MONERO_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password); -// virtual bool isBackgroundSyncing() const = 0; -extern ADDAPI bool MONERO_Wallet_isBackgroundSyncing(void* wallet_ptr); -// virtual bool isBackgroundWallet() const = 0; -extern ADDAPI bool MONERO_Wallet_isBackgroundWallet(void* wallet_ptr); -// virtual TransactionHistory * history() = 0; -extern ADDAPI void* MONERO_Wallet_history(void* wallet_ptr); -// virtual AddressBook * addressBook() = 0; -extern ADDAPI void* MONERO_Wallet_addressBook(void* wallet_ptr); -// virtual Coins * coins() = 0; -extern ADDAPI void* MONERO_Wallet_coins(void* wallet_ptr); -// virtual Subaddress * subaddress() = 0; -extern ADDAPI void* MONERO_Wallet_subaddress(void* wallet_ptr); -// virtual SubaddressAccount * subaddressAccount() = 0; -extern ADDAPI void* MONERO_Wallet_subaddressAccount(void* wallet_ptr); -// virtual void setListener(WalletListener *) = 0; -// virtual uint32_t defaultMixin() const = 0; -extern ADDAPI uint32_t MONERO_Wallet_defaultMixin(void* wallet_ptr); -// virtual void setDefaultMixin(uint32_t arg) = 0; -extern ADDAPI void MONERO_Wallet_setDefaultMixin(void* wallet_ptr, uint32_t arg); -// virtual bool setCacheAttribute(const std::string &key, const std::string &val) = 0; -extern ADDAPI bool MONERO_Wallet_setCacheAttribute(void* wallet_ptr, const char* key, const char* val); -// virtual std::string getCacheAttribute(const std::string &key) const = 0; -extern ADDAPI const char* MONERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key); -// virtual bool setUserNote(const std::string &txid, const std::string ¬e) = 0; -extern ADDAPI bool MONERO_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note); -// virtual std::string getUserNote(const std::string &txid) const = 0; -extern ADDAPI const char* MONERO_Wallet_getUserNote(void* wallet_ptr, const char* txid); -// virtual std::string getTxKey(const std::string &txid) const = 0; -extern ADDAPI const char* MONERO_Wallet_getTxKey(void* wallet_ptr, const char* txid); -// virtual bool checkTxKey(const std::string &txid, std::string tx_key, const std::string &address, uint64_t &received, bool &in_pool, uint64_t &confirmations) = 0; -// virtual std::string getTxProof(const std::string &txid, const std::string &address, const std::string &message) const = 0; -// virtual bool checkTxProof(const std::string &txid, const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &received, bool &in_pool, uint64_t &confirmations) = 0; -// virtual std::string getSpendProof(const std::string &txid, const std::string &message) const = 0; -// virtual bool checkSpendProof(const std::string &txid, const std::string &message, const std::string &signature, bool &good) const = 0; -// virtual std::string getReserveProof(bool all, uint32_t account_index, uint64_t amount, const std::string &message) const = 0; -// virtual bool checkReserveProof(const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &total, uint64_t &spent) const = 0; -// virtual std::string signMessage(const std::string &message, const std::string &address = "") = 0; -extern ADDAPI const char* MONERO_Wallet_signMessage(void* wallet_ptr, const char* message, const char* address); -// virtual bool verifySignedMessage(const std::string &message, const std::string &addres, const std::string &signature) const = 0; -extern ADDAPI bool MONERO_Wallet_verifySignedMessage(void* wallet_ptr, const char* message, const char* address, const char* signature); -// virtual std::string signMultisigParticipant(const std::string &message) const = 0; -// virtual bool verifyMessageWithPublicKey(const std::string &message, const std::string &publicKey, const std::string &signature) const = 0; -// virtual bool parse_uri(const std::string &uri, std::string &address, std::string &payment_id, uint64_t &amount, std::string &tx_description, std::string &recipient_name, std::vector &unknown_parameters, std::string &error) = 0; -// virtual std::string make_uri(const std::string &address, const std::string &payment_id, uint64_t amount, const std::string &tx_description, const std::string &recipient_name, std::string &error) const = 0; -// virtual std::string getDefaultDataDir() const = 0; -// virtual bool rescanSpent() = 0; -extern ADDAPI bool MONERO_Wallet_rescanSpent(void* wallet_ptr); -// virtual void setOffline(bool offline) = 0; -extern ADDAPI void MONERO_Wallet_setOffline(void* wallet_ptr, bool offline); -// virtual bool isOffline() const = 0; -extern ADDAPI bool MONERO_Wallet_isOffline(void* wallet_ptr); -// virtual bool blackballOutputs(const std::vector &outputs, bool add) = 0; -// virtual bool blackballOutput(const std::string &amount, const std::string &offset) = 0; -// virtual bool unblackballOutput(const std::string &amount, const std::string &offset) = 0; -// virtual bool getRing(const std::string &key_image, std::vector &ring) const = 0; -// virtual bool getRings(const std::string &txid, std::vector>> &rings) const = 0; -// virtual bool setRing(const std::string &key_image, const std::vector &ring, bool relative) = 0; -// virtual void segregatePreForkOutputs(bool segregate) = 0; -extern ADDAPI void MONERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate); -// virtual void segregationHeight(uint64_t height) = 0; -extern ADDAPI void MONERO_Wallet_segregationHeight(void* wallet_ptr, uint64_t height); -// virtual void keyReuseMitigation2(bool mitigation) = 0; -extern ADDAPI void MONERO_Wallet_keyReuseMitigation2(void* wallet_ptr, bool mitigation); -// virtual bool lightWalletLogin(bool &isNewWallet) const = 0; -// virtual bool lightWalletImportWalletRequest(std::string &payment_id, uint64_t &fee, bool &new_request, bool &request_fulfilled, std::string &payment_address, std::string &status) = 0; -// virtual bool lockKeysFile() = 0; -extern ADDAPI bool MONERO_Wallet_lockKeysFile(void* wallet_ptr); -// virtual bool unlockKeysFile() = 0; -extern ADDAPI bool MONERO_Wallet_unlockKeysFile(void* wallet_ptr); -// virtual bool isKeysFileLocked() = 0; -extern ADDAPI bool MONERO_Wallet_isKeysFileLocked(void* wallet_ptr); -// virtual Device getDeviceType() const = 0; -extern ADDAPI int MONERO_Wallet_getDeviceType(void* wallet_ptr); -// virtual uint64_t coldKeyImageSync(uint64_t &spent, uint64_t &unspent) = 0; -extern ADDAPI uint64_t MONERO_Wallet_coldKeyImageSync(void* wallet_ptr, uint64_t spent, uint64_t unspent); -// virtual void deviceShowAddress(uint32_t accountIndex, uint32_t addressIndex, const std::string &paymentId) = 0; -extern ADDAPI const char* MONERO_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex); -// virtual bool reconnectDevice() = 0; -extern ADDAPI bool MONERO_Wallet_reconnectDevice(void* wallet_ptr); -// virtual uint64_t getBytesReceived() = 0; -extern ADDAPI uint64_t MONERO_Wallet_getBytesReceived(void* wallet_ptr); -// virtual uint64_t getBytesSent() = 0; -extern ADDAPI uint64_t MONERO_Wallet_getBytesSent(void* wallet_ptr); - // HIDAPI_DUMMY -extern ADDAPI bool MONERO_Wallet_getStateIsConnected(); -extern ADDAPI unsigned char* MONERO_Wallet_getSendToDevice(); -extern ADDAPI size_t MONERO_Wallet_getSendToDeviceLength(); -extern ADDAPI unsigned char* MONERO_Wallet_getReceivedFromDevice(); -extern ADDAPI size_t MONERO_Wallet_getReceivedFromDeviceLength(); -extern ADDAPI bool MONERO_Wallet_getWaitsForDeviceSend(); -extern ADDAPI bool MONERO_Wallet_getWaitsForDeviceReceive(); -extern ADDAPI void MONERO_Wallet_setDeviceReceivedData(unsigned char* data, size_t len); -extern ADDAPI void MONERO_Wallet_setDeviceSendData(unsigned char* data, size_t len); -extern ADDAPI void MONERO_Wallet_setLedgerCallback(void (*sendToLedgerDevice)(unsigned char *command, unsigned int cmd_len)); -extern ADDAPI const char* MONERO_Wallet_serializeCacheToJson(void* wallet_ptr); -// }; - -// struct WalletManager -// { -// virtual Wallet * createWallet(const std::string &path, const std::string &password, const std::string &language, NetworkType nettype, uint64_t kdf_rounds = 1) = 0; -extern ADDAPI void* MONERO_WalletManager_createWallet(void* wm_ptr, const char* path, const char* password, const char* language, int networkType); -// Wallet * createWallet(const std::string &path, const std::string &password, const std::string &language, bool testnet = false) // deprecated -// { -// return createWallet(path, password, language, testnet ? TESTNET : MAINNET); -// } -// virtual Wallet * openWallet(const std::string &path, const std::string &password, NetworkType nettype, uint64_t kdf_rounds = 1, WalletListener * listener = nullptr) = 0; -extern ADDAPI void* MONERO_WalletManager_openWallet(void* wm_ptr, const char* path, const char* password, int networkType); -// Wallet * openWallet(const std::string &path, const std::string &password, bool testnet = false) // deprecated -// { -// return openWallet(path, password, testnet ? TESTNET : MAINNET); -// } -// virtual Wallet * recoveryWallet(const std::string &path, const std::string &password, const std::string &mnemonic, -// NetworkType nettype = MAINNET, uint64_t restoreHeight = 0, uint64_t kdf_rounds = 1, -// const std::string &seed_offset = {}) = 0; -extern ADDAPI void* MONERO_WalletManager_recoveryWallet(void* wm_ptr, const char* path, const char* password, const char* mnemonic, int networkType, uint64_t restoreHeight, uint64_t kdfRounds, const char* seedOffset); -// Wallet * recoveryWallet(const std::string &path, const std::string &password, const std::string &mnemonic, -// bool testnet = false, uint64_t restoreHeight = 0) // deprecated -// { -// return recoveryWallet(path, password, mnemonic, testnet ? TESTNET : MAINNET, restoreHeight); -// } -// virtual Wallet * recoveryWallet(const std::string &path, const std::string &mnemonic, NetworkType nettype, uint64_t restoreHeight = 0) = 0; -// Wallet * recoveryWallet(const std::string &path, const std::string &mnemonic, bool testnet = false, uint64_t restoreHeight = 0) // deprecated -// { -// return recoveryWallet(path, mnemonic, testnet ? TESTNET : MAINNET, restoreHeight); -// } -// virtual Wallet * createWalletFromKeys(const std::string &path, -// const std::string &password, -// const std::string &language, -// NetworkType nettype, -// uint64_t restoreHeight, -// const std::string &addressString, -// const std::string &viewKeyString, -// const std::string &spendKeyString = "", -// uint64_t kdf_rounds = 1) = 0; -extern ADDAPI void* MONERO_WalletManager_createWalletFromKeys(void* wm_ptr, const char* path, const char* password, const char* language, int nettype, uint64_t restoreHeight, const char* addressString, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds); -// Wallet * createWalletFromKeys(const std::string &path, -// const std::string &password, -// const std::string &language, -// bool testnet, -// uint64_t restoreHeight, -// const std::string &addressString, -// const std::string &viewKeyString, -// const std::string &spendKeyString = "") // deprecated -// { -// return createWalletFromKeys(path, password, language, testnet ? TESTNET : MAINNET, restoreHeight, addressString, viewKeyString, spendKeyString); -// } -// virtual Wallet * createWalletFromKeys(const std::string &path, -// const std::string &language, -// NetworkType nettype, -// uint64_t restoreHeight, -// const std::string &addressString, -// const std::string &viewKeyString, -// const std::string &spendKeyString = "") = 0; -// Wallet * createWalletFromKeys(const std::string &path, -// const std::string &language, -// bool testnet, -// uint64_t restoreHeight, -// const std::string &addressString, -// const std::string &viewKeyString, -// const std::string &spendKeyString = "") // deprecated -// { -// return createWalletFromKeys(path, language, testnet ? TESTNET : MAINNET, restoreHeight, addressString, viewKeyString, spendKeyString); -// } -// virtual Wallet * createDeterministicWalletFromSpendKey(const std::string &path, -// const std::string &password, -// const std::string &language, -// NetworkType nettype, -// uint64_t restoreHeight, -// const std::string &spendKeyString, -// uint64_t kdf_rounds = 1) = 0; -extern ADDAPI void* MONERO_WalletManager_createDeterministicWalletFromSpendKey(void* wm_ptr, const char* path, const char* password, - const char* language, int nettype, uint64_t restoreHeight, - const char* spendKeyString, uint64_t kdf_rounds); -// virtual Wallet * createWalletFromDevice(const std::string &path, -// const std::string &password, -// NetworkType nettype, -// const std::string &deviceName, -// uint64_t restoreHeight = 0, -// const std::string &subaddressLookahead = "", -// uint64_t kdf_rounds = 1, -// WalletListener * listener = nullptr) = 0; -extern ADDAPI void* MONERO_WalletManager_createWalletFromDevice(void* wm_ptr, const char* path, const char* password, int nettype, const char* deviceName, uint64_t restoreHeight, const char* subaddressLookahead, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds); -// virtual Wallet * createWalletFromPolyseed(const std::string &path, -// const std::string &password, -// NetworkType nettype, -// const std::string &mnemonic, -// const std::string &passphrase = "", -// bool newWallet = true, -// uint64_t restore_height = 0, -// uint64_t kdf_rounds = 1) = 0; -extern ADDAPI void* MONERO_WalletManager_createWalletFromPolyseed(void* wm_ptr, const char* path, const char* password, - int nettype, const char* mnemonic, const char* passphrase, - bool newWallet, uint64_t restore_height, uint64_t kdf_rounds); -// virtual bool closeWallet(Wallet *wallet, bool store = true) = 0; -extern ADDAPI bool MONERO_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store); -// virtual bool walletExists(const std::string &path) = 0; -extern ADDAPI bool MONERO_WalletManager_walletExists(void* wm_ptr, const char* path); -// virtual bool verifyWalletPassword(const std::string &keys_file_name, const std::string &password, bool no_spend_key, uint64_t kdf_rounds = 1) const = 0; -extern ADDAPI bool MONERO_WalletManager_verifyWalletPassword(void* wm_ptr, const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds); -// virtual bool queryWalletDevice(Wallet::Device& device_type, const std::string &keys_file_name, const std::string &password, uint64_t kdf_rounds = 1) const = 0; -extern ADDAPI int MONERO_WalletManager_queryWalletDevice(void* wm_ptr, const char* keys_file_name, const char* password, uint64_t kdf_rounds); -// virtual std::vector findWallets(const std::string &path) = 0; -extern ADDAPI const char* MONERO_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator); -// virtual std::string errorString() const = 0; -extern ADDAPI const char* MONERO_WalletManager_errorString(void* wm_ptr); -// virtual void setDaemonAddress(const std::string &address) = 0; -extern ADDAPI void MONERO_WalletManager_setDaemonAddress(void* wm_ptr, const char* address); -// virtual bool connected(uint32_t *version = NULL) = 0; -// virtual uint64_t blockchainHeight() = 0; -extern ADDAPI uint64_t MONERO_WalletManager_blockchainHeight(void* wm_ptr); -// virtual uint64_t blockchainTargetHeight() = 0; -extern ADDAPI uint64_t MONERO_WalletManager_blockchainTargetHeight(void* wm_ptr); -// virtual uint64_t networkDifficulty() = 0; -extern ADDAPI uint64_t MONERO_WalletManager_networkDifficulty(void* wm_ptr); -// virtual double miningHashRate() = 0; -extern ADDAPI double MONERO_WalletManager_miningHashRate(void* wm_ptr); -// virtual uint64_t blockTarget() = 0; -extern ADDAPI uint64_t MONERO_WalletManager_blockTarget(void* wm_ptr); -// virtual bool isMining() = 0; -extern ADDAPI bool MONERO_WalletManager_isMining(void* wm_ptr); -// virtual bool startMining(const std::string &address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true) = 0; -extern ADDAPI bool MONERO_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery); -// virtual bool stopMining() = 0; -extern ADDAPI bool MONERO_WalletManager_stopMining(void* wm_ptr, const char* address); -// virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0; -extern ADDAPI const char* MONERO_WalletManager_resolveOpenAlias(void* wm_ptr, const char* address, bool dnssec_valid); -// static std::tuple checkUpdates( -// const std::string &software, -// std::string subdir, -// const char *buildtag = nullptr, -// const char *current_version = nullptr); -// virtual bool setProxy(const std::string &address) = 0; -extern ADDAPI bool MONERO_WalletManager_setProxy(void* wm_ptr, const char* address); -// }; - -int LogLevel_Silent = -1; -int LogLevel_0 = 0; -int LogLevel_1 = 1; -int LogLevel_2 = 2; -int LogLevel_3 = 3; -int LogLevel_4 = 4; -int LogLevel_Min = -1; -int LogLevel_Max = 4; - -// struct WalletManagerFactory -// { -// enum LogLevel { -// LogLevel_Silent = -1, -// LogLevel_0 = 0, -// LogLevel_1 = 1, -// LogLevel_2 = 2, -// LogLevel_3 = 3, -// LogLevel_4 = 4, -// LogLevel_Min = LogLevel_Silent, -// LogLevel_Max = LogLevel_4 -// }; -// static WalletManager * getWalletManager(); -extern ADDAPI void* MONERO_WalletManagerFactory_getWalletManager(); -// static void setLogLevel(int level); -extern ADDAPI void MONERO_WalletManagerFactory_setLogLevel(int level); -// static void setLogCategories(const std::string &categories); -extern ADDAPI void MONERO_WalletManagerFactory_setLogCategories(const char* categories); -// }; -// } - -extern ADDAPI void MONERO_DEBUG_test0(); -extern ADDAPI bool MONERO_DEBUG_test1(bool x); -extern ADDAPI int MONERO_DEBUG_test2(int x); -extern ADDAPI uint64_t MONERO_DEBUG_test3(uint64_t x); -extern ADDAPI void* MONERO_DEBUG_test4(uint64_t x); -extern ADDAPI const char* MONERO_DEBUG_test5(); -extern ADDAPI const char* MONERO_DEBUG_test5_std(); -extern ADDAPI bool MONERO_DEBUG_isPointerNull(void* wallet_ptr); - -// cake world - -extern ADDAPI void* MONERO_cw_getWalletListener(void* wallet_ptr); -extern ADDAPI void MONERO_cw_WalletListener_resetNeedToRefresh(void* cw_walletListener_ptr); -extern ADDAPI bool MONERO_cw_WalletListener_isNeedToRefresh(void* cw_walletListener_ptr); -extern ADDAPI bool MONERO_cw_WalletListener_isNewTransactionExist(void* cw_walletListener_ptr); -extern ADDAPI void MONERO_cw_WalletListener_resetIsNewTransactionExist(void* cw_walletListener_ptr); -extern ADDAPI uint64_t MONERO_cw_WalletListener_height(void* cw_walletListener_ptr); - -extern ADDAPI void MONERO_free(void* ptr); - -extern ADDAPI const char* MONERO_checksum_wallet2_api_c_h(); -extern ADDAPI const char* MONERO_checksum_wallet2_api_c_cpp(); -extern ADDAPI const char* MONERO_checksum_wallet2_api_c_exp(); - -#ifdef __cplusplus -} -#endif diff --git a/tests/c/Makefile b/tests/c/Makefile new file mode 100644 index 0000000..0384acc --- /dev/null +++ b/tests/c/Makefile @@ -0,0 +1,58 @@ +CC ?= gcc +CFLAGS ?= -Wall -Wextra -O2 -Isrc -I../../monero_libwallet2_api_c/src/main/cpp -Itests +LDFLAGS ?= + +UNAME_S := $(shell uname -s) + +ifeq ($(OS),Windows_NT) + LIB_EXT := dll +else ifeq ($(UNAME_S),Darwin) + LIB_EXT := dylib +else + LIB_EXT := so +endif + +UNAME_S := $(shell uname -s) +UNAME_M := $(shell uname -m) + +# Normalize architecture +ifeq ($(UNAME_M),x86_64) + ARCH := x86_64 +else ifeq ($(UNAME_M),aarch64) + ARCH := aarch64 +else ifeq ($(UNAME_M),arm64) + ARCH := aarch64 +else + ARCH := $(UNAME_M) +endif + +# Normalize OS +ifeq ($(UNAME_S),Darwin) + OS := apple-darwin +else ifeq ($(UNAME_S),Linux) + OS := linux-gnu +else + OS := unknown-$(shell echo $(UNAME_S) | tr A-Z a-z) +endif + +HOST_ABI := $(ARCH)-$(OS) + +LIB_DIR ?= ../../release/$(shell git describe --tags)/$(HOST_ABI) + +SRC_DIRS ?= src tests +SRCS := $(wildcard $(addsuffix /*.c,$(SRC_DIRS))) +OBJS := $(SRCS:.c=.o) +TARGET = test_wallet2_api_c + +.PHONY: all clean + +all: $(TARGET) + +$(TARGET): $(OBJS) + $(CC) $(OBJS) -o $@ -L$(LIB_DIR) -lmonero_wallet2_api_c -Wl,-rpath,$(LIB_DIR) $(LDFLAGS) + +%.o: %.c + $(CC) $(CFLAGS) -c $< -o $@ + +clean: + rm -f $(OBJS) $(TARGET) diff --git a/tests/c/src/main.c b/tests/c/src/main.c new file mode 100644 index 0000000..0ae418f --- /dev/null +++ b/tests/c/src/main.c @@ -0,0 +1,12 @@ +#include +#include +#include +#include "../tests/all.h" + + +int main() { + monero_test_creation(); + monero_test_restore(); + printf("All tests passed\n"); + return 0; +} diff --git a/tests/c/src/utils.c b/tests/c/src/utils.c new file mode 100644 index 0000000..9816075 --- /dev/null +++ b/tests/c/src/utils.c @@ -0,0 +1,65 @@ +#include "utils.h" +#include +#include +#include +#include + +char* u_mktemp() { + char pattern[] = "/tmp/monero_c_test_XXXXXXXXX"; + + char *template = malloc(strlen(pattern) + 1); + if (!template) { + perror("malloc failed"); + exit(1); + } + + strcpy(template, pattern); + + if (mkdtemp(template) == NULL) { + perror("mkdtemp failed"); + free(template); + exit(1); + } + + return template; +} + +char* u_cat(const char* a, const char* b) { + size_t len_a = strlen(a); + size_t len_b = strlen(b); + + char* result = malloc(len_a + len_b + 1); + if (!result) { + perror("malloc failed"); + exit(1); + } + + memcpy(result, a, len_a); + memcpy(result + len_a, b, len_b + 1); // include null terminator + + return result; +} + +int u_wordcount(const char* str) { + if (!str) return 0; + + int count = 0; + int in_word = 0; + + for (size_t i = 0; str[i]; i++) { + // Japan smh (　= 0xE3 0x80 0x80) + int is_space = (str[i] == ' ') || + ((unsigned char)str[i] == 0xE3 && + (unsigned char)str[i+1] == 0x80 && + (unsigned char)str[i+2] == 0x80); + + if (is_space) { + in_word = 0; + } else if (!in_word) { + in_word = 1; + count++; + } + } + + return count; +} diff --git a/tests/c/src/utils.h b/tests/c/src/utils.h new file mode 100644 index 0000000..dd99556 --- /dev/null +++ b/tests/c/src/utils.h @@ -0,0 +1,8 @@ +#ifndef UTILS_H +#define UTILS_H + +char* u_mktemp(); +char* u_cat(const char* a, const char* b); +int u_wordcount(const char* str); + +#endif // UTILS_H diff --git a/tests/c/tests/all.h b/tests/c/tests/all.h new file mode 100644 index 0000000..cba87d8 --- /dev/null +++ b/tests/c/tests/all.h @@ -0,0 +1,7 @@ +#ifndef ALL_H +#define ALL_H + +int monero_test_creation(); +int monero_test_restore(); + +#endif // ALL_H diff --git a/tests/c/tests/monero_test_creation.c b/tests/c/tests/monero_test_creation.c new file mode 100644 index 0000000..193cd08 --- /dev/null +++ b/tests/c/tests/monero_test_creation.c @@ -0,0 +1,55 @@ +#include "../src/utils.h" +#include "../../../monero_libwallet2_api_c/src/main/cpp/monero_wallet2_api_c.h" +#include +#include +#include + +int monero_test_creation_legacy() { + printf("monero_test_creation_legacy: "); + char* dir = u_mktemp(); + char* path = u_cat(dir, "/wallet_1"); + void* wm_ptr = MONERO_WalletManagerFactory_getWalletManager(); + void* wallet_ptr = MONERO_WalletManager_createWallet(wm_ptr, path, "test", "English", 0); + int status = MONERO_Wallet_status(wallet_ptr); + if (status != 0) { + const char* error = MONERO_Wallet_errorString(wallet_ptr); + printf("wallet creation failed: %s\n", error); + exit(1); + } + printf("OK\n"); + return 0; +} + + +int monero_test_creation_polyseed() { + printf("monero_test_creation_polyseed: "); + char* dir = u_mktemp(); + char* path = u_cat(dir, "/wallet_1"); + void* wm_ptr = MONERO_WalletManagerFactory_getWalletManager(); + const char* polyseed = MONERO_Wallet_createPolyseed("English"); + + void* wallet_ptr = MONERO_WalletManager_createWalletFromPolyseed( + wm_ptr, + path, + "password", + MONERO_NetworkType_MAINNET, + polyseed, + "", + false, + 0, + 0); + int status = MONERO_Wallet_status(wallet_ptr); + if (status != 0) { + const char* error = MONERO_Wallet_errorString(wallet_ptr); + printf("wallet creation failed: %s\n", error); + exit(1); + } + printf("OK\n"); + return 0; +} + +int monero_test_creation() { + monero_test_creation_legacy(); + monero_test_creation_polyseed(); + return 0; +} diff --git a/tests/c/tests/monero_test_restore.c b/tests/c/tests/monero_test_restore.c new file mode 100644 index 0000000..ec7cecc --- /dev/null +++ b/tests/c/tests/monero_test_restore.c @@ -0,0 +1,255 @@ +#include +#include +#include +#include +#include +#include +#include "../src/utils.h" +#include "../../../monero_libwallet2_api_c/src/main/cpp/monero_wallet2_api_c.h" + +typedef struct { + char *name; + char *password; + char *seed; + unsigned long long restoreHeight; + char *address; + char *publicSpendKey; + char *secretSpendKey; + char *publicViewKey; + char *secretViewKey; + char *offset; +} Wallet; + +Wallet moneroWallets[] = { + { + .name = "English Wallet", + .password = "englishwallet", + .seed = "tortoise winter play argue laptop diary tell library travel cupboard view river embark rubber plunge student", + .restoreHeight = 3230397, + .address = "49PL6qHMkc4Hw3dWT5wy5NbbVd2xda8zw3tLx2BoQsNZUWDQYYpwMEKjB9BLbEKSo3S3z34bncFw6ijToTwfiEJJ5m8aefx", + .publicSpendKey = "ccd6846ab69fdd653a8d092d89590dced40aa2862f3c24113fedfcd6469162a4", + .secretSpendKey = "37fd2e3e933c8468beb407e5350789e23bed5df33eeeb35d3b119401988e6709", + .publicViewKey = "6f0de7385aafd4fc259cbd0abb069295c5d3824b7e1b81f97ffcf8cccde6c72a", + .secretViewKey = "b8095208d61fc22e4ee3a79347a889e4872cdcf1cceff991542834cef5375907", + }, + { + .name = "Chinese Traditional Wallet", + .password = "chinesetraditionalwallet", + .seed = "旗 铁 革 酯 紧 毅 饱 应 第 兄 植 隙 点 吐 童 赞", + .restoreHeight = 3230397, + .address = "4AR8YW51Ga3DR4a47F5J8rXaqyBa8pnnF557pTyt52ZqNMFa3gfxvi13R7sbt5zHfjbF5aKsLFZQrRod3qcr5MQj4f91rLh", + .publicSpendKey = "e80bab7b3e2d384a393b825cf4f2abb6d8d08f1742d87c1856c064a609a0647f", + .secretSpendKey = "c7de78f9819db6755e14d2e1411f1591c2d0b3a6ee19049c30e270f81eb50401", + .publicViewKey = "a366527c3a6d160e717ebaac11d08eccb95586991a4c87944ad750331adac020", + .secretViewKey = "aab2ea0dc6fa2745c8c7113399242c03300664a21cac9202c315ad789b67d004", + }, + { + .name = "Chinese Simplified Wallet", + .password = "chinesesimplifiedwallet", + .seed = "纹 触 集 驶 朋 辨 你 版 是 益 驳 修 偏 汽 录 吨", + .restoreHeight = 3230397, + .address = "47E7p1mFGNj59QNfjpXcopP1YZuGdn7NhYJv25xbPKdicnThww5DUv2aNMH7oPWsKZjQQmXMkBzUze2T6gAaXafLAF9E4Dz", + .publicSpendKey = "93dec0155d30b818c7d64a0b0c3a678395e3e28bdd736abb2ef7c360b38449d5", + .secretSpendKey = "60084b4ff3d99d6ca38876078721c13692635429c74ef5d71f03310cf2e0690b", + .publicViewKey = "eff74761051a2fc77eac4d7ed1b564fd83c0e3e924199bdd5ba66b4bf4ecf351", + .secretViewKey = "3bde0d3a1bd2877f75fc9f6ea331c976d26a62e469db1d11ddaef2cce9405d02", + }, + { + .name = "Japanese Wallet", + .password = "japanesewallet", + .seed = "きほん　ことば　そうび　きどう　なまえ　ひさしぶり　ごうけい　ふひょう　ぎゅうにく　しはらい　きびしい　はんとし　ととのえる　たかい　とかい　るりがわら", + .restoreHeight = 3230397 , + .address = "45YYsW5do7NjGSaRZPAkPQ9mi4HQsMv3w86HFddtkZi4cCbqtFiVoqJjdFobCtCwpBPZWSnUtmrU2G9fLpEE7vsQU3aZyeE", + .publicSpendKey = "677ac034b7c3e9fcb178370e3df067346ff5703db8273e2a65010862a85935d2", + .secretSpendKey = "1fe9110cc46c58ed0f5cb6c6e189e246f6c3cfbf459de2ed1565838b6e08780e", + .publicViewKey = "7276d8537e0cd9fed6b9327177ed9086e159f7d63b9fb35a92693cdbf322ffef", + .secretViewKey = "f3c8f4121cdf07616453f005e7f2cf0474cf3608ec632f4e81165ec1c5b4aa0c", + }, + { + .name = "Korean Wallet", + .password = "koreanwallet", + .seed = "단골 운전 일대 제작 구역 보자기 대한민국 답장 쇼핑 논문 편견 대전 충돌 강당 형제 볼펜", + .restoreHeight = 3230397, + .address = "42DNYppLMXki8j3urYuXaTU1S9EBrSJ71aVNbzr4fKfnXryMwJ2rFt6Y5eCP9vpej9AdrZqNFXDFB1VmkjzjX5e5URJ9q8c", + .publicSpendKey = "0f96caeac7cd4ff5eb55810b4eb87ca1779637e949d138c837fe9a776b3c51b8", + .secretSpendKey = "d86c40f13694e7511499cdb22db4e96ee2990cfffde52274248bb8818a36c406", + .publicViewKey = "826438a35b0f63b9d0b877269a0468399b3f60513e079602f73c4b0f7cd0e6f3", + .secretViewKey = "3773b61c0cac3a2e15d03b989461704c6e90916561c6b98d035bd3d2caf88c05", + }, + { + .name = "Portugese Wallet", + .password = "portugesewallet", + .seed = "inscrito raposa vermelho medusa apetite bacharel quantia usado poupar pilotar sigilo ideia robalo ignorado desgaste intimar", + .restoreHeight = 3230397, + .address = "43xw29tpLnU5VaPZ8Nuzz7DqrnUip5tmWBn3aukkZAyzgHTscJHvESy6pmYutLebQAB9TJgGhoCAWhPK6WJ39CpiD29fbwj", + .publicSpendKey = "3dcbbde593acc11adc291eeeec8bc44cc7943192d54fb1406de435b4d7b73dea", + .secretSpendKey = "9b94f57038b07b8280f27cedbed6e53472b48fe4683de15cc9e034fdddfcbb05", + .publicViewKey = "dce02ef2ca595e22d1242a53b5235f3ca8508e22386d03f171bc77ef856e1b6a", + .secretViewKey = "27bdd486a74f9b7c7a79c39c8ff7438a3fc862bb1ec3f6ef035a8acedf876705", + }, + { + .name = "Czech Wallet", + .password = "czechwallet", + .seed = "ulice louskat odmlka parodie dominant slanina sukno vodivost zimnice vykonat sundat kalibr dobro moucha kometa legenda", + .restoreHeight = 3230397, + .address = "499LrJgGPkFA1BPvF4xqr5bwZfKyCZah1C2CEhvqpW7YGQddwWYyR2L1F1TJhqyxxwa4TXKYZM4bb8ukq3kein1cPMNLLi4", + .publicSpendKey = "c6796799947e0c35d3720af264d6a6d0e5a574cea1cde441e343b828a00c875c", + .secretSpendKey = "61f9c86a71744a101c36b5628c1c4324e49e84861f136cbd2d0f1477ba5ace0b", + .publicViewKey = "1d75ed535e3dfd0171a4a714aef368c5a6862aaf9972422f49cd76d232f88fc6", + .secretViewKey = "47fd8eadc1848a09b343815a74185835a0b2cc8567e61022322dd52f6aaf2004", + }, + { + .name = "Spanish Wallet", + .password = "spanishwallet", + .seed = "rehén torpedo remo existir fuente dama culpa riqueza cebolla supremo vereda odio novio sumar espía margen", + .restoreHeight = 3230397, + .address = "41xeBwVJEpVVrJntrvUXafJR4mk9x3tfW3zXxamh8G951SM9BbBLgJSgzwdCywLRrbZvipLL2Azu9jKbu4Y9Hey3MUF6f19", + .publicSpendKey = "08e31c09ad35beac7bcb9e4a689e40681df1b42cd2686511e344d02606bfc802", + .secretSpendKey = "19ae689bdd594fde5d06b66e4c7a89d9783c02694ae615e33928b38f0c52120c", + .publicViewKey = "9cdf4adfd9c7c7ef236c9084a0ceb4c4da6017b9fd1b6cfd04e02527ea6f06b5", + .secretViewKey = "40ae98266cadfbf546e861cac2b2e93ce921f9db2e02f072d86aea274a182006", + }, + { + .name = "Italian Wallet", + .password = "italianwallet", + .seed = "fuso rinvenire astenuto camicia erboso icona bollito esito spettrale abisso dogma appunto prefisso gracile podismo araldica", + .restoreHeight = 3230397, + .address = "46Kkbh8jLorHRKJEV7C4hNczZknHeB6w4GHpLWkpfThMdPLeeU8MFRmDfMqioYyacCTAG9wZ9y9UHZDNhehEssDVHePj3Ja", + .publicSpendKey = "7c0b928d9d8349622a07673a9721e9d72f60ccfc8e83935b699c379999104cd9", + .secretSpendKey = "673b61bdb369cc61a022e0eab47e5e41cf86e99a80979f75ebcda1219ee0ab01", + .publicViewKey = "8858e908f756c44bb286d5b657824d9c660386c7db0b0ec0974d268a7432bc93", + .secretViewKey = "5012dbfa9e1cd2a30c2a18654dc9c8bee128af8fe7246c46e5f4def76705fe0f", + }, + { + .name = "English Wallet (offset)", + .password = "englishwallet", + .seed = "loud fix cattle broken right main web rather write aunt left nation broken ship program ten", + .offset = "englishoffset", + .restoreHeight = 3230397, + .address = "4B2QGWy9as7bwwLNq2DQ26Q3woahpTLbR7d8vJE1uKL5gobU9iMydFqbVrYa9ixfrnAvnuwT9BXpkBx1APocbJfb2drFuQi", + .publicSpendKey = "f817ca86625d1ed0ef81ccb8a4e82b89cfc3345512c7b82798ba2f5982b7daed", + .secretSpendKey = "39ae15e92e08a0903652b4b0f187d740d2a5bf08e77879babb345b9a78ca6504", + .publicViewKey = "f7fb585b9a288cce3f3b1a5f0ca6873b5a2fef8afb3bd94174ac31cbed53620e", + .secretViewKey = "d5676e49438b0cd38c6a699ab783c11f21e1a7ebc1c9174121e37456a97f380d", + }, +}; + +size_t moneroWalletsCount = sizeof(moneroWallets) / sizeof(moneroWallets[0]); + +int monero_test_restore() { + printf("monero_test_restore: BEGIN\n"); + for (size_t i = 0; i < moneroWalletsCount; i++) { + Wallet *wallet = &moneroWallets[i]; + + char *dir = u_mktemp(); + char *name = u_cat(dir, "/wallet_"); + char *path = u_cat(name, wallet->name); + free(name); + + printf(" - %s: ", wallet->name); + void* wm_ptr = MONERO_WalletManagerFactory_getWalletManager(); + const char* offset = wallet->offset ? wallet->offset : ""; + void* wallet_ptr; + + int seedWordCount = u_wordcount(wallet->seed); + switch (seedWordCount) { + case 16: + wallet_ptr = MONERO_WalletManager_createWalletFromPolyseed( + wm_ptr, + path, + wallet->password, + MONERO_NetworkType_MAINNET, + wallet->seed, + offset, + false, + wallet->restoreHeight, + 0); + break; + case 25: + wallet_ptr = MONERO_WalletManager_recoveryWallet( + wm_ptr, + path, + wallet->password, + wallet->seed, + MONERO_NetworkType_MAINNET, + wallet->restoreHeight, + 0, + offset); + break; + default: + printf("unsupported seed word count: %d\n", seedWordCount); + exit(1); + } + + + int status = MONERO_Wallet_status(wallet_ptr); + if (status != 0) { + const char* error = MONERO_Wallet_errorString(wallet_ptr); + printf("wallet creation failed: %s\n", error); + exit(1); + } + + bool result = MONERO_Wallet_init(wallet_ptr, "", 0, "", "", false, false, ""); + if (!result) { + const char* error = MONERO_Wallet_errorString(wallet_ptr); + printf("wallet init failed: %s\n", error); + exit(1); + } + + // const char* password = MONERO_Wallet_getPassword(wallet_ptr); + // if (strcmp(password, wallet->password) != 0) { + // printf("wallet password mismatch (%s vs %s)\n", password, wallet->password); + // exit(1); + // } + + if (seedWordCount == 25) { + const char* seed = MONERO_Wallet_seed(wallet_ptr, wallet->offset); + if (strcmp(seed, wallet->seed) != 0) { + printf("wallet seed mismatch\n"); + exit(1); + } + } + + uint64_t restoreHeight = MONERO_Wallet_getRefreshFromBlockHeight(wallet_ptr); + if (restoreHeight != wallet->restoreHeight) { + printf("wallet restore height mismatch (%llu vs %llu)\n", restoreHeight, wallet->restoreHeight); + exit(1); + } + + const char* address = MONERO_Wallet_address(wallet_ptr, 0, 0); + if (strcmp(address, wallet->address) != 0) { + printf("wallet address mismatch\n"); + exit(1); + } + + const char* publicSpendKey = MONERO_Wallet_publicSpendKey(wallet_ptr); + if (strcmp(publicSpendKey, wallet->publicSpendKey) != 0) { + printf("wallet public spend key mismatch\n"); + exit(1); + } + + const char* secretSpendKey = MONERO_Wallet_secretSpendKey(wallet_ptr); + if (strcmp(secretSpendKey, wallet->secretSpendKey) != 0) { + printf("wallet secret spend key mismatch\n"); + exit(1); + } + + const char* publicViewKey = MONERO_Wallet_publicViewKey(wallet_ptr); + if (strcmp(publicViewKey, wallet->publicViewKey) != 0) { + printf("wallet public view key mismatch\n"); + exit(1); + } + + const char* secretViewKey = MONERO_Wallet_secretViewKey(wallet_ptr); + if (strcmp(secretViewKey, wallet->secretViewKey) != 0) { + printf("wallet secret view key mismatch\n"); + exit(1); + } + + free(dir); + free(path); + printf("OK\n"); + } + printf("monero_test_restore: END\n"); + return 0; +} diff --git a/wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp b/wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp deleted file mode 100644 index 44887f6..0000000 --- a/wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp +++ /dev/null @@ -1,2515 +0,0 @@ -#include -#include "wallet2_api_c.h" -#include -#include "helpers.hpp" -#include -#include -#include "../../../../wownero/src/wallet/api/wallet2_api.h" -#include "../../../wownero-seed/include/wownero_seed/wownero_seed.hpp" -#include "wownero_checksum.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - - -// The code in here consists of simple wrappers, that convert -// more advanced c++ types (and function names) into simple C-compatible -// functions, so these implementations can be easly used from all languages -// that do support C interop (such as dart) -// -// -// Here is the most complex definition that we can find in the current codebase, it even includes -// a if statement - which in general I consider an anti-patter in just wrappers -// -// _____________ void* because C++ wallet->createTransaction returns a pointer to Monero::PendingTransaction, which we don't want to have exposed in C land -// / _____________ MONERO prefix just means that this function is using monero codebase, to not cause any symbols collision when using more than one libwallet2_api_c.so in a single program. -// | / _____________ Wallet is one of the classes in Monero namespace in the upstream codebase (see the include line above) -// | | / _____________ aaand it is calling createTransaction function. -// | | | / _________________________________________________________________________________ -// | | | | / \ All of these parameters can be found in the upstream -// | | | | | _____________/ function definition, if something was more complex - -// void* WOWNERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, / like std::set I've used splitString functions and introduced a new -// uint64_t amount, uint32_t mixin_count, / parameter - separator, as it is the simplest way to get vector onto -// int pendingTransactionPriority, / C side from more advanced world. -// uint32_t subaddr_account, / -// const char* preferredInputs, const char* separator) { -// Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); <------------ We are converting the void* into Monero::Wallet* -// Monero::optional optAmount; <------------- optional by default -// if (amount != 0) {------------------\ We set this optional parameter only when it isn't zero -// optAmount = amount; | -// }___________________________________/ -// std::set subaddr_indices = {}; ------------- Default value -// std::set preferred_inputs = splitString(std::string(preferredInputs), std::string(separator)); <------------- We are using helpers.cpp function to split a string into std::set -// return wallet->createTransaction(std::string(dst_addr), std::string(payment_id),-\ const char * is getting casted onto std::string -// optAmount, mixin_count, \_____________/ -// PendingTransaction_Priority_fromInt(pendingTransactionPriority), <------------- special case for this function to get native type instead of int value. -// subaddr_account, subaddr_indices, preferred_inputs); -// } -// -// -// One case which is not covered here is when we have to return a string -// const char* WOWNERO_PendingTransaction_errorString(void* pendingTx_ptr) { -// Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); -// std::string str = pendingTx->errorString(); <------------- get the actual string from the upstream codebase -// const std::string::size_type size = str.size(); ------------------------------\ -// char *buffer = new char[size + 1]; //we need extra char for NUL | Copy the string onto a new memory so it won't get freed after the function returns -// memcpy(buffer, str.c_str(), size + 1); | NOTE: This requires us to call free() after we are done with the text processing -// return buffer; ______________________________________________________________/ -// } -// -// - -// PendingTransaction - -int WOWNERO_PendingTransaction_status(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - return pendingTx->status(); - DEBUG_END() -} -const char* WOWNERO_PendingTransaction_errorString(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::string str = pendingTx->errorString(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -bool WOWNERO_PendingTransaction_commit(void* pendingTx_ptr, const char* filename, bool overwrite) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - return pendingTx->commit(std::string(filename), overwrite); - DEBUG_END() -} -uint64_t WOWNERO_PendingTransaction_amount(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - return pendingTx->amount(); - DEBUG_END() -} -uint64_t WOWNERO_PendingTransaction_dust(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - return pendingTx->dust(); - DEBUG_END() -} -uint64_t WOWNERO_PendingTransaction_fee(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - return pendingTx->fee(); - DEBUG_END() -} -const char* WOWNERO_PendingTransaction_txid(void* pendingTx_ptr, const char* separator) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::vector txid = pendingTx->txid(); - return vectorToString(txid, std::string(separator)); - DEBUG_END() -} -uint64_t WOWNERO_PendingTransaction_txCount(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - return pendingTx->txCount(); - DEBUG_END() -} -const char* WOWNERO_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::vector subaddrAccount = pendingTx->subaddrAccount(); - return vectorToString(subaddrAccount, std::string(separator)); - DEBUG_END() -} -const char* WOWNERO_PendingTransaction_subaddrIndices(void* pendingTx_ptr, const char* separator) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::vector> subaddrIndices = pendingTx->subaddrIndices(); - return vectorToString(subaddrIndices, std::string(separator)); - DEBUG_END() -} -const char* WOWNERO_PendingTransaction_multisigSignData(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::string str = pendingTx->multisigSignData(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -void WOWNERO_PendingTransaction_signMultisigTx(void* pendingTx_ptr) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - return pendingTx->signMultisigTx(); - DEBUG_END() -} -const char* WOWNERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::vector txid = pendingTx->signersKeys(); - return vectorToString(txid, std::string(separator)); - DEBUG_END() -} - -const char* WOWNERO_PendingTransaction_hex(void* pendingTx_ptr, const char* separator) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::vector txid = pendingTx->hex(); - return vectorToString(txid, std::string(separator)); - DEBUG_END() -} - -// const char* WOWNERO_PendingTransaction_txHex(void* pendingTx_ptr, const char* separator) { -// Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); -// std::vector txid = pendingTx->txHex(); -// return vectorToString(txid, std::string(separator)); -// } - -const char* WOWNERO_PendingTransaction_txKey(void* pendingTx_ptr, const char* separator) { - DEBUG_START() - Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); - std::vector txid = pendingTx->txKey(); - return vectorToString(txid, std::string(separator)); - DEBUG_END() -} - -// UnsignedTransaction - -int WOWNERO_UnsignedTransaction_status(void* unsignedTx_ptr) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return unsignedTx->status(); - DEBUG_END() -} -const char* WOWNERO_UnsignedTransaction_errorString(void* unsignedTx_ptr) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - std::string str = unsignedTx->errorString(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -const char* WOWNERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return vectorToString(unsignedTx->amount(), std::string(separator)); - DEBUG_END() -} -const char* WOWNERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return vectorToString(unsignedTx->fee(), std::string(separator)); - DEBUG_END() -} -const char* WOWNERO_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return vectorToString(unsignedTx->mixin(), std::string(separator)); - DEBUG_END() -} -const char* WOWNERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - std::string str = unsignedTx->confirmationMessage(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -const char* WOWNERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return vectorToString(unsignedTx->paymentId(), std::string(separator)); - DEBUG_END() -} -const char* WOWNERO_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return vectorToString(unsignedTx->recipientAddress(), std::string(separator)); - DEBUG_END() -} -uint64_t WOWNERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return unsignedTx->minMixinCount(); - DEBUG_END() -} -uint64_t WOWNERO_UnsignedTransaction_txCount(void* unsignedTx_ptr) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return unsignedTx->txCount(); - DEBUG_END() -} -bool WOWNERO_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName) { - DEBUG_START() - Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); - return unsignedTx->sign(std::string(signedFileName)); - DEBUG_END() -} - -// TransactionInfo -int WOWNERO_TransactionInfo_direction(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->direction(); - DEBUG_END() -} -bool WOWNERO_TransactionInfo_isPending(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->isPending(); - DEBUG_END() -} -bool WOWNERO_TransactionInfo_isFailed(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->isFailed(); - DEBUG_END() -} -bool WOWNERO_TransactionInfo_isCoinbase(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->isCoinbase(); - DEBUG_END() -} -uint64_t WOWNERO_TransactionInfo_amount(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->amount(); - DEBUG_END() -} -uint64_t WOWNERO_TransactionInfo_fee(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->fee(); - DEBUG_END() -} -uint64_t WOWNERO_TransactionInfo_blockHeight(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->blockHeight(); - DEBUG_END() -} -const char* WOWNERO_TransactionInfo_description(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - std::string str = txInfo->description(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -const char* WOWNERO_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - std::set subaddrIndex = txInfo->subaddrIndex(); - return vectorToString(subaddrIndex, std::string(separator)); - DEBUG_END() -} -uint32_t WOWNERO_TransactionInfo_subaddrAccount(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->subaddrAccount(); - DEBUG_END() -} -const char* WOWNERO_TransactionInfo_label(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - std::string str = txInfo->label(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -uint64_t WOWNERO_TransactionInfo_confirmations(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->confirmations(); - DEBUG_END() -} -uint64_t WOWNERO_TransactionInfo_unlockTime(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->unlockTime(); - DEBUG_END() -} -const char* WOWNERO_TransactionInfo_hash(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - std::string str = txInfo->hash(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -uint64_t WOWNERO_TransactionInfo_timestamp(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->timestamp(); - DEBUG_END() -} -const char* WOWNERO_TransactionInfo_paymentId(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - std::string str = txInfo->paymentId(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -int WOWNERO_TransactionInfo_transfers_count(void* txInfo_ptr) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->transfers().size(); - DEBUG_END() -} - -uint64_t WOWNERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - return txInfo->transfers()[index].amount; - DEBUG_END() -} - -const char* WOWNERO_TransactionInfo_transfers_address(void* txInfo_ptr, int index) { - DEBUG_START() - Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); - std::string str = txInfo->transfers()[index].address; - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - - - - -// TransactionHistory -int WOWNERO_TransactionHistory_count(void* txHistory_ptr) { - DEBUG_START() - Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); - return txHistory->count(); - DEBUG_END() -} -void* WOWNERO_TransactionHistory_transaction(void* txHistory_ptr, int index) { - DEBUG_START() - Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); - return reinterpret_cast(txHistory->transaction(index)); - DEBUG_END() -} -void* WOWNERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id) { - DEBUG_START() - Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); - return reinterpret_cast(txHistory->transaction(std::string(id))); - DEBUG_END() -} - -void WOWNERO_TransactionHistory_refresh(void* txHistory_ptr) { - DEBUG_START() - Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); - return txHistory->refresh(); - DEBUG_END() -} -void WOWNERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note) { - DEBUG_START() - Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); - return txHistory->setTxNote(std::string(txid), std::string(note)); - DEBUG_END() -} - -// AddressBokRow - -// std::string extra; -const char* WOWNERO_AddressBookRow_extra(void* addressBookRow_ptr) { - DEBUG_START() - Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); - std::string str = addressBookRow->extra; - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getAddress() const {return m_address;} -const char* WOWNERO_AddressBookRow_getAddress(void* addressBookRow_ptr) { - DEBUG_START() - Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); - std::string str = addressBookRow->getAddress(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getDescription() const {return m_description;} -const char* WOWNERO_AddressBookRow_getDescription(void* addressBookRow_ptr) { - DEBUG_START() - Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); - std::string str = addressBookRow->getDescription(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getPaymentId() const {return m_paymentId;} -const char* WOWNERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr) { - DEBUG_START() - Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); - std::string str = addressBookRow->getPaymentId(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::size_t getRowId() const {return m_rowId;} -size_t WOWNERO_AddressBookRow_getRowId(void* addressBookRow_ptr) { - DEBUG_START() - Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); - return addressBookRow->getRowId(); - DEBUG_END() -} - -// AddressBook -// virtual std::vector getAll() const = 0; -int WOWNERO_AddressBook_getAll_size(void* addressBook_ptr) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->getAll().size(); - DEBUG_END() -} -void* WOWNERO_AddressBook_getAll_byIndex(void* addressBook_ptr, int index) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->getAll()[index]; - DEBUG_END() -} -// virtual bool addRow(const std::string &dst_addr , const std::string &payment_id, const std::string &description) = 0; -bool WOWNERO_AddressBook_addRow(void* addressBook_ptr, const char* dst_addr , const char* payment_id, const char* description) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->addRow(std::string(dst_addr), std::string(payment_id), std::string(description)); - DEBUG_END() -} -// virtual bool deleteRow(std::size_t rowId) = 0; -bool WOWNERO_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->deleteRow(rowId); - DEBUG_END() -} -// virtual bool setDescription(std::size_t index, const std::string &description) = 0; -bool WOWNERO_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->setDescription(rowId, std::string(description)); - DEBUG_END() -} -// virtual void refresh() = 0; -void WOWNERO_AddressBook_refresh(void* addressBook_ptr) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->refresh(); - DEBUG_END() -} -// virtual std::string errorString() const = 0; -const char* WOWNERO_AddressBook_errorString(void* addressBook_ptr) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - std::string str = addressBook->errorString(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual int errorCode() const = 0; -int WOWNERO_AddressBook_errorCode(void* addressBook_ptr) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->errorCode(); - DEBUG_END() -} -// virtual int lookupPaymentID(const std::string &payment_id) const = 0; -int WOWNERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id) { - DEBUG_START() - Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); - return addressBook->lookupPaymentID(std::string(payment_id)); - DEBUG_END() -} - -// CoinsInfo -uint64_t WOWNERO_CoinsInfo_blockHeight(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->blockHeight(); - DEBUG_END() -} -// virtual std::string hash() const = 0; -const char* WOWNERO_CoinsInfo_hash(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - std::string str = coinsInfo->hash(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual size_t internalOutputIndex() const = 0; -size_t WOWNERO_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->internalOutputIndex(); - DEBUG_END() -} -// virtual uint64_t globalOutputIndex() const = 0; -uint64_t WOWNERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->globalOutputIndex(); - DEBUG_END() -} -// virtual bool spent() const = 0; -bool WOWNERO_CoinsInfo_spent(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->spent(); - DEBUG_END() -} -// virtual bool frozen() const = 0; -bool WOWNERO_CoinsInfo_frozen(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->frozen(); - DEBUG_END() -} -// virtual uint64_t spentHeight() const = 0; -uint64_t WOWNERO_CoinsInfo_spentHeight(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->spentHeight(); - DEBUG_END() -} -// virtual uint64_t amount() const = 0; -uint64_t WOWNERO_CoinsInfo_amount(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->amount(); - DEBUG_END() -} -// virtual bool rct() const = 0; -bool WOWNERO_CoinsInfo_rct(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->rct(); - DEBUG_END() -} -// virtual bool keyImageKnown() const = 0; -bool WOWNERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->keyImageKnown(); - DEBUG_END() -} -// virtual size_t pkIndex() const = 0; -size_t WOWNERO_CoinsInfo_pkIndex(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->pkIndex(); - DEBUG_END() -} -// virtual uint32_t subaddrIndex() const = 0; -uint32_t WOWNERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->subaddrIndex(); - DEBUG_END() -} -// virtual uint32_t subaddrAccount() const = 0; -uint32_t WOWNERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->subaddrAccount(); - DEBUG_END() -} -// virtual std::string address() const = 0; -const char* WOWNERO_CoinsInfo_address(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - std::string str = coinsInfo->address(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual std::string addressLabel() const = 0; -const char* WOWNERO_CoinsInfo_addressLabel(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - std::string str = coinsInfo->addressLabel(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual std::string keyImage() const = 0; -const char* WOWNERO_CoinsInfo_keyImage(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - std::string str = coinsInfo->keyImage(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual uint64_t unlockTime() const = 0; -uint64_t WOWNERO_CoinsInfo_unlockTime(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->unlockTime(); - DEBUG_END() -} -// virtual bool unlocked() const = 0; -bool WOWNERO_CoinsInfo_unlocked(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->unlocked(); - DEBUG_END() -} -// virtual std::string pubKey() const = 0; -const char* WOWNERO_CoinsInfo_pubKey(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - std::string str = coinsInfo->pubKey(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual bool coinbase() const = 0; -bool WOWNERO_CoinsInfo_coinbase(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - return coinsInfo->coinbase(); - DEBUG_END() -} -// virtual std::string description() const = 0; -const char* WOWNERO_CoinsInfo_description(void* coinsInfo_ptr) { - DEBUG_START() - Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); - std::string str = coinsInfo->description(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - - -// coins - -// virtual ~Coins() = 0; -// virtual int count() const = 0; -int WOWNERO_Coins_count(void* coins_ptr) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->count(); - DEBUG_END() -} -// virtual CoinsInfo * coin(int index) const = 0; -void* WOWNERO_Coins_coin(void* coins_ptr, int index) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->coin(index); - DEBUG_END() -} - -int WOWNERO_Coins_getAll_size(void* coins_ptr) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->getAll().size(); - DEBUG_END() -} -void* WOWNERO_Coins_getAll_byIndex(void* coins_ptr, int index) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->getAll()[index]; - DEBUG_END() -} - -// virtual std::vector getAll() const = 0; -// virtual void refresh() = 0; -void WOWNERO_Coins_refresh(void* coins_ptr) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->refresh(); - DEBUG_END() -} -// virtual void setFrozen(std::string public_key) = 0; -void WOWNERO_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->setFrozen(std::string(public_key)); - DEBUG_END() -} -// virtual void setFrozen(int index) = 0; -void WOWNERO_Coins_setFrozen(void* coins_ptr, int index) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->setFrozen(index); - DEBUG_END() -} -// virtual void thaw(int index) = 0; -void WOWNERO_Coins_thaw(void* coins_ptr, int index) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->thaw(index); - DEBUG_END() -} -// virtual void thaw(std::string public_key) = 0; -void WOWNERO_Coins_thawByPublicKey(void* coins_ptr, const char* public_key) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->thaw(std::string(public_key)); - DEBUG_END() -} -// virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0; -bool WOWNERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - return coins->isTransferUnlocked(unlockTime, blockHeight); - DEBUG_END() -} -// virtual void setDescription(const std::string &public_key, const std::string &description) = 0; -void WOWNERO_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description) { - DEBUG_START() - Monero::Coins *coins = reinterpret_cast(coins_ptr); - coins->setDescription(std::string(public_key), std::string(description)); - DEBUG_END() -} - -// SubaddressRow - -// std::string extra; -const char* WOWNERO_SubaddressRow_extra(void* subaddressRow_ptr) { - DEBUG_START() - Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); - std::string str = subaddressRow->extra; - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getAddress() const {return m_address;} -const char* WOWNERO_SubaddressRow_getAddress(void* subaddressRow_ptr) { - DEBUG_START() - Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); - std::string str = subaddressRow->getAddress(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getLabel() const {return m_label;} -const char* WOWNERO_SubaddressRow_getLabel(void* subaddressRow_ptr) { - DEBUG_START() - Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); - std::string str = subaddressRow->getLabel(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::size_t getRowId() const {return m_rowId;} -size_t WOWNERO_SubaddressRow_getRowId(void* subaddressRow_ptr) { - DEBUG_START() - Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); - return subaddressRow->getRowId(); - DEBUG_END() -} - -// Subaddress - -int WOWNERO_Subaddress_getAll_size(void* subaddress_ptr) { - DEBUG_START() - Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); - return subaddress->getAll().size(); - DEBUG_END() -} -void* WOWNERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index) { - DEBUG_START() - Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); - return subaddress->getAll()[index]; - DEBUG_END() -} -// virtual void addRow(uint32_t accountIndex, const std::string &label) = 0; -void WOWNERO_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label) { - DEBUG_START() - Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); - return subaddress->addRow(accountIndex, std::string(label)); - DEBUG_END() -} -// virtual void setLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0; -void WOWNERO_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label) { - DEBUG_START() - Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); - return subaddress->setLabel(accountIndex, addressIndex, std::string(label)); - DEBUG_END() -} -// virtual void refresh(uint32_t accountIndex) = 0; -void WOWNERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex) { - DEBUG_START() - Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); - return subaddress->refresh(accountIndex); - DEBUG_END() -} - -// SubaddressAccountRow - -// std::string extra; -const char* WOWNERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr) { - DEBUG_START() - Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); - std::string str = subaddressAccountRow->extra; - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getAddress() const {return m_address;} -const char* WOWNERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr) { - DEBUG_START() - Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); - std::string str = subaddressAccountRow->getAddress(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getLabel() const {return m_label;} -const char* WOWNERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr) { - DEBUG_START() - Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); - std::string str = subaddressAccountRow->getLabel(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getBalance() const {return m_balance;} -const char* WOWNERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr) { - DEBUG_START() - Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); - std::string str = subaddressAccountRow->getBalance(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string getUnlockedBalance() const {return m_unlockedBalance;} -const char* WOWNERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr) { - DEBUG_START() - Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); - std::string str = subaddressAccountRow->getUnlockedBalance(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::size_t getRowId() const {return m_rowId;} -size_t WOWNERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr) { - DEBUG_START() - Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); - return subaddressAccountRow->getRowId(); - DEBUG_END() -} - -// struct SubaddressAccount -// { -// virtual ~SubaddressAccount() = 0; -// virtual std::vector getAll() const = 0; -int WOWNERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr) { - DEBUG_START() - Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); - return subaddress->getAll().size(); - DEBUG_END() -} -void* WOWNERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index) { - DEBUG_START() - Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); - return subaddress->getAll()[index]; - DEBUG_END() -} -// virtual void addRow(const std::string &label) = 0; -void WOWNERO_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label) { - DEBUG_START() - Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); - return subaddress->addRow(std::string(label)); - DEBUG_END() -} -// virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0; -void WOWNERO_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label) { - DEBUG_START() - Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); - return subaddress->setLabel(accountIndex, std::string(label)); - DEBUG_END() -} -// virtual void refresh() = 0; -void WOWNERO_SubaddressAccount_refresh(void* subaddressAccount_ptr) { - DEBUG_START() - Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); - return subaddress->refresh(); - DEBUG_END() -} - -// MultisigState - -// bool isMultisig; -bool WOWNERO_MultisigState_isMultisig(void* multisigState_ptr) { - DEBUG_START() - Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); - return multisigState->isMultisig; - DEBUG_END() -} -// bool isReady; -bool WOWNERO_MultisigState_isReady(void* multisigState_ptr) { - DEBUG_START() - Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); - return multisigState->isReady; - DEBUG_END() -} -// uint32_t threshold; -uint32_t WOWNERO_MultisigState_threshold(void* multisigState_ptr) { - DEBUG_START() - Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); - return multisigState->threshold; - DEBUG_END() -} -// uint32_t total; -uint32_t WOWNERO_MultisigState_total(void* multisigState_ptr) { - DEBUG_START() - Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); - return multisigState->total; - DEBUG_END() -} - -// DeviceProgress - - -// virtual double progress() const { return m_progress; } -bool WOWNERO_DeviceProgress_progress(void* deviceProgress_ptr) { - DEBUG_START() - Monero::DeviceProgress *deviceProgress = reinterpret_cast(deviceProgress_ptr); - return deviceProgress->progress(); - DEBUG_END() -} -// virtual bool indeterminate() const { return m_indeterminate; } -bool WOWNERO_DeviceProgress_indeterminate(void* deviceProgress_ptr) { - DEBUG_START() - Monero::DeviceProgress *deviceProgress = reinterpret_cast(deviceProgress_ptr); - return deviceProgress->indeterminate(); - DEBUG_END() -} - -// Wallet - -const char* WOWNERO_Wallet_seed(void* wallet_ptr, const char* seed_offset) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->seed(std::string(seed_offset)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* WOWNERO_Wallet_getSeedLanguage(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->getSeedLanguage(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -void WOWNERO_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setSeedLanguage(std::string(arg)); - DEBUG_END() -} - -int WOWNERO_Wallet_status(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->status(); - DEBUG_END() -} - -const char* WOWNERO_Wallet_errorString(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->errorString(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - - -bool WOWNERO_Wallet_setPassword(void* wallet_ptr, const char* password) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setPassword(std::string(password)); - DEBUG_END() -} - -const char* WOWNERO_Wallet_getPassword(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->getPassword(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -bool WOWNERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setDevicePin(std::string(pin)); - DEBUG_END() -} - -bool WOWNERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setDevicePassphrase(std::string(passphrase)); - DEBUG_END() -} - -const char* WOWNERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->address(accountIndex, addressIndex); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* WOWNERO_Wallet_path(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->path(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -int WOWNERO_Wallet_nettype(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->nettype(); - DEBUG_END() -} -uint8_t WOWNERO_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->useForkRules(version, early_blocks); - DEBUG_END() -} -const char* WOWNERO_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->integratedAddress(std::string(payment_id)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* WOWNERO_Wallet_secretViewKey(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->secretViewKey(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* WOWNERO_Wallet_publicViewKey(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->publicViewKey(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* WOWNERO_Wallet_secretSpendKey(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->secretSpendKey(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* WOWNERO_Wallet_publicSpendKey(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->publicSpendKey(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -const char* WOWNERO_Wallet_publicMultisigSignerKey(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->publicMultisigSignerKey(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -void WOWNERO_Wallet_stop(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - wallet->stop(); - DEBUG_END() -} - -bool WOWNERO_Wallet_store(void* wallet_ptr, const char* path) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->store(std::string(path)); - DEBUG_END() -} -const char* WOWNERO_Wallet_filename(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->filename(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -const char* WOWNERO_Wallet_keysFilename(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->keysFilename(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -// virtual bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit = 0, const std::string &daemon_username = "", const std::string &daemon_password = "", bool use_ssl = false, bool lightWallet = false, const std::string &proxy_address = "") = 0; -bool WOWNERO_Wallet_init(void* wallet_ptr, const char* daemon_address, uint64_t upper_transaction_size_limit, const char* daemon_username, const char* daemon_password, bool use_ssl, bool lightWallet, const char* proxy_address) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->init(std::string(daemon_address), upper_transaction_size_limit, std::string(daemon_username), std::string(daemon_password), use_ssl, lightWallet, std::string(proxy_address)); - DEBUG_END() -} -bool WOWNERO_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->createWatchOnly(std::string(path), std::string(password), std::string(language)); - DEBUG_END() -} - -void WOWNERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setRefreshFromBlockHeight(refresh_from_block_height); - DEBUG_END() -} - -uint64_t WOWNERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->getRefreshFromBlockHeight(); - DEBUG_END() -} - -void WOWNERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setRecoveringFromSeed(recoveringFromSeed); - DEBUG_END() -} -void WOWNERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setRecoveringFromDevice(recoveringFromDevice); - DEBUG_END() -} -void WOWNERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setSubaddressLookahead(major, minor); - DEBUG_END() -} - -bool WOWNERO_Wallet_connectToDaemon(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->connectToDaemon(); - DEBUG_END() -} -int WOWNERO_Wallet_connected(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->connected(); - DEBUG_END() -} -void WOWNERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setTrustedDaemon(arg); - DEBUG_END() -} -bool WOWNERO_Wallet_trustedDaemon(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->trustedDaemon(); - DEBUG_END() -} -bool WOWNERO_Wallet_setProxy(void* wallet_ptr, const char* address) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setProxy(std::string(address)); - DEBUG_END() -} - -uint64_t WOWNERO_Wallet_balance(void* wallet_ptr, uint32_t accountIndex) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->balance(accountIndex); - DEBUG_END() -} - -uint64_t WOWNERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->unlockedBalance(accountIndex); - DEBUG_END() -} - -uint64_t WOWNERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->viewOnlyBalance(accountIndex); - DEBUG_END() -} - -// TODO -bool WOWNERO_Wallet_watchOnly(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->watchOnly(); - DEBUG_END() -} -bool WOWNERO_Wallet_isDeterministic(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->isDeterministic(); - DEBUG_END() -} -uint64_t WOWNERO_Wallet_blockChainHeight(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->blockChainHeight(); - DEBUG_END() -} -uint64_t WOWNERO_Wallet_approximateBlockChainHeight(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->approximateBlockChainHeight(); - DEBUG_END() -} -uint64_t WOWNERO_Wallet_estimateBlockChainHeight(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->estimateBlockChainHeight(); - DEBUG_END() -} -uint64_t WOWNERO_Wallet_daemonBlockChainHeight(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->daemonBlockChainHeight(); - DEBUG_END() -} - -uint64_t WOWNERO_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->daemonBlockChainTargetHeight(); - DEBUG_END() -} -bool WOWNERO_Wallet_synchronized(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->synchronized(); - DEBUG_END() -} - -const char* WOWNERO_Wallet_displayAmount(uint64_t amount) { - DEBUG_START() - std::string str = Monero::Wallet::displayAmount(amount); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -// static uint64_t amountFromString(const std::string &amount); -uint64_t WOWNERO_Wallet_amountFromString(const char* amount) { - DEBUG_START() - return Monero::Wallet::amountFromString(amount); - DEBUG_END() -} -// static uint64_t amountFromDouble(double amount); -uint64_t WOWNERO_Wallet_amountFromDouble(double amount) { - DEBUG_START() - return Monero::Wallet::amountFromDouble(amount); - DEBUG_END() -} -// static std::string genPaymentId(); -const char* WOWNERO_Wallet_genPaymentId() { - DEBUG_START() - std::string str = Monero::Wallet::genPaymentId(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// static bool paymentIdValid(const std::string &paiment_id); -bool WOWNERO_Wallet_paymentIdValid(const char* paiment_id) { - DEBUG_START() - return Monero::Wallet::paymentIdValid(std::string(paiment_id)); - DEBUG_END() -} -bool WOWNERO_Wallet_addressValid(const char* str, int nettype) { - DEBUG_START() - // Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return Monero::Wallet::addressValid(std::string(str), nettype); - DEBUG_END() -} - -bool WOWNERO_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype) { - DEBUG_START() - std::string error; - return Monero::Wallet::keyValid(std::string(secret_key_string), std::string(address_string), isViewKey, nettype, error); - DEBUG_END() -} -const char* WOWNERO_Wallet_keyValid_error(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype) { - DEBUG_START() - std::string str; - Monero::Wallet::keyValid(std::string(secret_key_string), std::string(address_string), isViewKey, nettype, str); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -const char* WOWNERO_Wallet_paymentIdFromAddress(const char* strarg, int nettype) { - DEBUG_START() - std::string str = Monero::Wallet::paymentIdFromAddress(std::string(strarg), nettype); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -uint64_t WOWNERO_Wallet_maximumAllowedAmount() { - DEBUG_START() - return Monero::Wallet::maximumAllowedAmount(); - DEBUG_END() -} - -void WOWNERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->init(argv0, default_log_base_name, log_path, console); - DEBUG_END() -} -const char* WOWNERO_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string seed = ""; - std::string _passphrase = std::string(passphrase); - wallet->getPolyseed(seed, _passphrase); - std::string str = seed; - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// static bool createPolyseed(std::string &seed_words, std::string &err, const std::string &language = "English"); -const char* WOWNERO_Wallet_createPolyseed(const char* language) { - DEBUG_START() - std::string seed_words = ""; - std::string err; - Monero::Wallet::createPolyseed(seed_words, err, std::string(language)); - std::cout << "WOWNERO_Wallet_createPolyseed(language: " << language << "):" << std::endl; - std::cout << " err: " << err << std::endl; - std::string str = seed_words; - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -void WOWNERO_Wallet_startRefresh(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->startRefresh(); - DEBUG_END() -} -void WOWNERO_Wallet_pauseRefresh(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->pauseRefresh(); - DEBUG_END() -} -bool WOWNERO_Wallet_refresh(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->refresh(); - DEBUG_END() -} -void WOWNERO_Wallet_refreshAsync(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->refreshAsync(); - DEBUG_END() -} -bool WOWNERO_Wallet_rescanBlockchain(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->rescanBlockchain(); - DEBUG_END() -} -void WOWNERO_Wallet_rescanBlockchainAsync(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->rescanBlockchainAsync(); - DEBUG_END() -} -void WOWNERO_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setAutoRefreshInterval(millis); - DEBUG_END() -} -int WOWNERO_Wallet_autoRefreshInterval(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->autoRefreshInterval(); - DEBUG_END() -} -void WOWNERO_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->addSubaddressAccount(std::string(label)); - DEBUG_END() -} -size_t WOWNERO_Wallet_numSubaddressAccounts(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->numSubaddressAccounts(); - DEBUG_END() -} -size_t WOWNERO_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->numSubaddresses(accountIndex); - DEBUG_END() -} -void WOWNERO_Wallet_addSubaddress(void* wallet_ptr, uint32_t accountIndex, const char* label) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->addSubaddress(accountIndex, std::string(label)); - DEBUG_END() -} -const char* WOWNERO_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->getSubaddressLabel(accountIndex, addressIndex); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -void WOWNERO_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setSubaddressLabel(accountIndex, addressIndex, std::string(label)); - DEBUG_END() -} -const char* WOWNERO_Wallet_getMultisigInfo(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->getMultisigInfo(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -Monero::PendingTransaction::Priority PendingTransaction_Priority_fromInt(int value) { - switch(value) { - case 0: return Monero::PendingTransaction::Priority::Priority_Default; - case 1: return Monero::PendingTransaction::Priority::Priority_Low; - case 2: return Monero::PendingTransaction::Priority::Priority_Medium; - case 3: return Monero::PendingTransaction::Priority::Priority_High; - default: return Monero::PendingTransaction::Priority::Priority_Default; - } -} - -void* WOWNERO_Wallet_createTransactionMultDest(void* wallet_ptr, const char* dst_addr_list, const char* dst_addr_list_separator, const char* payment_id, - bool amount_sweep_all, const char* amount_list, const char* amount_list_separator, uint32_t mixin_count, - int pendingTransactionPriority, - uint32_t subaddr_account, - const char* preferredInputs, const char* preferredInputs_separator) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::vector dst_addr = splitStringVector(std::string(dst_addr_list), std::string(dst_addr_list_separator)); - - Monero::optional> optAmount; - if (!amount_sweep_all) { - optAmount = splitStringUint(std::string(amount_list), std::string(amount_list_separator));; - } - std::set subaddr_indices = {}; - std::set preferred_inputs = splitString(std::string(preferredInputs), std::string(preferredInputs_separator)); - - return wallet->createTransactionMultDest( - dst_addr, std::string(payment_id), - optAmount, mixin_count, - PendingTransaction_Priority_fromInt(pendingTransactionPriority), - subaddr_account, - subaddr_indices, - preferred_inputs - ); - DEBUG_END() -} - -void* WOWNERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, - uint64_t amount, uint32_t mixin_count, - int pendingTransactionPriority, - uint32_t subaddr_account, - const char* preferredInputs, const char* separator) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - Monero::optional optAmount; - if (amount != 0) { - optAmount = amount; - } - std::set subaddr_indices = {}; - std::set preferred_inputs = splitString(std::string(preferredInputs), std::string(separator)); - return wallet->createTransaction(std::string(dst_addr), std::string(payment_id), - optAmount, mixin_count, - PendingTransaction_Priority_fromInt(pendingTransactionPriority), - subaddr_account, subaddr_indices, preferred_inputs); - DEBUG_END() -} - -void* WOWNERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* fileName) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->loadUnsignedTx(std::string(fileName)); - DEBUG_END() -} -bool WOWNERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->submitTransaction(std::string(fileName)); - DEBUG_END() -} -bool WOWNERO_Wallet_hasUnknownKeyImages(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->hasUnknownKeyImages(); - DEBUG_END() -} -bool WOWNERO_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->exportKeyImages(std::string(filename), all); - DEBUG_END() -} -bool WOWNERO_Wallet_importKeyImages(void* wallet_ptr, const char* filename) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->importKeyImages(std::string(filename)); - DEBUG_END() -} -bool WOWNERO_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool all) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->exportOutputs(std::string(filename), all); - DEBUG_END() -} -bool WOWNERO_Wallet_importOutputs(void* wallet_ptr, const char* filename) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->importOutputs(std::string(filename)); - DEBUG_END() -} -// virtual bool setupBackgroundSync(const BackgroundSyncType background_sync_type, const std::string &wallet_password, const optional &background_cache_password) = 0; -bool WOWNERO_Wallet_setupBackgroundSync(void* wallet_ptr, int background_sync_type, const char* wallet_password, const char* background_cache_password) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setupBackgroundSync(Monero::Wallet::BackgroundSyncType::BackgroundSync_CustomPassword, std::string(wallet_password), std::string(background_cache_password)); - DEBUG_END() -} -// virtual BackgroundSyncType getBackgroundSyncType() const = 0; -int WOWNERO_Wallet_getBackgroundSyncType(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->getBackgroundSyncType(); - DEBUG_END() -} -// virtual bool startBackgroundSync() = 0; -bool WOWNERO_Wallet_startBackgroundSync(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->startBackgroundSync(); - DEBUG_END() -} -// virtual bool stopBackgroundSync(const std::string &wallet_password) = 0; -bool WOWNERO_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->stopBackgroundSync(std::string(wallet_password)); - DEBUG_END() -} -// virtual bool isBackgroundSyncing() const = 0; -bool WOWNERO_Wallet_isBackgroundSyncing(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->hasUnknownKeyImages(); - DEBUG_END() -} -// virtual bool isBackgroundWallet() const = 0; -bool WOWNERO_Wallet_isBackgroundWallet(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->isBackgroundWallet(); - DEBUG_END() -} -void* WOWNERO_Wallet_history(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->history(); - DEBUG_END() -} -void* WOWNERO_Wallet_addressBook(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->addressBook(); - DEBUG_END() -} -// virtual Coins * coins() = 0; -void* WOWNERO_Wallet_coins(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->coins(); - DEBUG_END() -} -// virtual Subaddress * subaddress() = 0; -void* WOWNERO_Wallet_subaddress(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->subaddress(); - DEBUG_END() -} -// virtual SubaddressAccount * subaddressAccount() = 0; -void* WOWNERO_Wallet_subaddressAccount(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->subaddressAccount(); - DEBUG_END() -} -// virtual uint32_t defaultMixin() const = 0; -uint32_t WOWNERO_Wallet_defaultMixin(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->defaultMixin(); - DEBUG_END() -} -// virtual void setDefaultMixin(uint32_t arg) = 0; -void WOWNERO_Wallet_setDefaultMixin(void* wallet_ptr, uint32_t arg) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setDefaultMixin(arg); - DEBUG_END() -} -// virtual bool setCacheAttribute(const std::string &key, const std::string &val) = 0; -bool WOWNERO_Wallet_setCacheAttribute(void* wallet_ptr, const char* key, const char* val) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setCacheAttribute(std::string(key), std::string(val)); - DEBUG_END() -} -// virtual std::string getCacheAttribute(const std::string &key) const = 0; -const char* WOWNERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->getCacheAttribute(std::string(key)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual bool setUserNote(const std::string &txid, const std::string ¬e) = 0; -bool WOWNERO_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setUserNote(std::string(txid), std::string(note)); - DEBUG_END() -} -// virtual std::string getUserNote(const std::string &txid) const = 0; -const char* WOWNERO_Wallet_getUserNote(void* wallet_ptr, const char* txid) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->getUserNote(std::string(txid)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* WOWNERO_Wallet_getTxKey(void* wallet_ptr, const char* txid) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->getTxKey(std::string(txid)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -const char* WOWNERO_Wallet_signMessage(void* wallet_ptr, const char* message, const char* address) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = wallet->signMessage(std::string(message), std::string(address)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -bool WOWNERO_Wallet_verifySignedMessage(void* wallet_ptr, const char* message, const char* address, const char* signature) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - bool v = wallet->verifySignedMessage(std::string(message), std::string(address), std::string(signature)); - return v; - DEBUG_END() -} - -bool WOWNERO_Wallet_rescanSpent(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->rescanSpent(); - DEBUG_END() -} - -void WOWNERO_Wallet_setOffline(void* wallet_ptr, bool offline) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->setOffline(offline); - DEBUG_END() -} -// virtual bool isOffline() const = 0; -bool WOWNERO_Wallet_isOffline(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->isOffline(); - DEBUG_END() -} - -void WOWNERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->segregatePreForkOutputs(segregate); - DEBUG_END() -} -// virtual void segregationHeight(uint64_t height) = 0; -void WOWNERO_Wallet_segregationHeight(void* wallet_ptr, uint64_t height) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->segregationHeight(height); - DEBUG_END() -} -// virtual void keyReuseMitigation2(bool mitigation) = 0; -void WOWNERO_Wallet_keyReuseMitigation2(void* wallet_ptr, bool mitigation) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->keyReuseMitigation2(mitigation); - DEBUG_END() -} -// virtual bool lightWalletLogin(bool &isNewWallet) const = 0; -// virtual bool lightWalletImportWalletRequest(std::string &payment_id, uint64_t &fee, bool &new_request, bool &request_fulfilled, std::string &payment_address, std::string &status) = 0; -// virtual bool lockKeysFile() = 0; -bool WOWNERO_Wallet_lockKeysFile(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->lockKeysFile(); - DEBUG_END() -} -// virtual bool unlockKeysFile() = 0; -bool WOWNERO_Wallet_unlockKeysFile(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->unlockKeysFile(); - DEBUG_END() -} -// virtual bool isKeysFileLocked() = 0; -bool WOWNERO_Wallet_isKeysFileLocked(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->isKeysFileLocked(); - DEBUG_END() -} -// virtual Device getDeviceType() const = 0; -int WOWNERO_Wallet_getDeviceType(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->getDeviceType(); - DEBUG_END() -} -// virtual uint64_t coldKeyImageSync(uint64_t &spent, uint64_t &unspent) = 0; -uint64_t WOWNERO_Wallet_coldKeyImageSync(void* wallet_ptr, uint64_t spent, uint64_t unspent) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->coldKeyImageSync(spent, unspent); - DEBUG_END() -} -// virtual void deviceShowAddress(uint32_t accountIndex, uint32_t addressIndex, const std::string &paymentId) = 0; -const char* WOWNERO_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - std::string str = ""; - wallet->deviceShowAddress(accountIndex, addressIndex, str); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// virtual bool reconnectDevice() = 0; -bool WOWNERO_Wallet_reconnectDevice(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->reconnectDevice(); - DEBUG_END() -}; - -uint64_t WOWNERO_Wallet_getBytesReceived(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->getBytesReceived(); - DEBUG_END() -} -uint64_t WOWNERO_Wallet_getBytesSent(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wallet->getBytesSent(); - DEBUG_END() -} - - -void* WOWNERO_WalletManager_createWallet(void* wm_ptr, const char* path, const char* password, const char* language, int networkType) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - Monero::Wallet *wallet = wm->createWallet( - std::string(path), - std::string(password), - std::string(language), - static_cast(networkType)); - return reinterpret_cast(wallet); - DEBUG_END() -} - -void* WOWNERO_WalletManager_openWallet(void* wm_ptr, const char* path, const char* password, int networkType) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - Monero::Wallet *wallet = wm->openWallet( - std::string(path), - std::string(password), - static_cast(networkType)); - return reinterpret_cast(wallet); - DEBUG_END() -} -void* WOWNERO_WalletManager_recoveryWallet(void* wm_ptr, const char* path, const char* password, const char* mnemonic, int networkType, uint64_t restoreHeight, uint64_t kdfRounds, const char* seedOffset) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - // (const std::string &path, const std::string &password, const std::string &mnemonic, - // NetworkType nettype = MAINNET, uint64_t restoreHeight = 0, uint64_t kdf_rounds = 1, - // const std::string &seed_offset = {}) - Monero::Wallet *wallet = wm->recoveryWallet( - std::string(path), - std::string(password), - std::string(mnemonic), - static_cast(networkType), - restoreHeight, - kdfRounds, - std::string(seedOffset)); - return reinterpret_cast(wallet); - DEBUG_END() -} -// virtual Wallet * createWalletFromKeys(const std::string &path, -// const std::string &password, -// const std::string &language, -// NetworkType nettype, -// uint64_t restoreHeight, -// const std::string &addressString, -// const std::string &viewKeyString, -// const std::string &spendKeyString = "", -// uint64_t kdf_rounds = 1) = 0; -void* WOWNERO_WalletManager_createWalletFromKeys(void* wm_ptr, const char* path, const char* password, const char* language, int nettype, uint64_t restoreHeight, const char* addressString, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - Monero::Wallet *wallet = wm->createWalletFromKeys( - std::string(path), - std::string(password), - std::string(language), - static_cast(nettype), - restoreHeight, - std::string(addressString), - std::string(viewKeyString), - std::string(spendKeyString)); - return reinterpret_cast(wallet); - DEBUG_END() -} - -void* WOWNERO_WalletManager_createDeterministicWalletFromSpendKey(void* wm_ptr, const char* path, const char* password, - const char* language, int nettype, uint64_t restoreHeight, - const char* spendKeyString, uint64_t kdf_rounds) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - Monero::Wallet *wallet = wm->createDeterministicWalletFromSpendKey( - std::string(path), - std::string(password), - std::string(language), - static_cast(nettype), - restoreHeight, - std::string(spendKeyString), - kdf_rounds - ); - return reinterpret_cast(wallet); - DEBUG_END() -} - -void* WOWNERO_WalletManager_createWalletFromPolyseed(void* wm_ptr, const char* path, const char* password, - int nettype, const char* mnemonic, const char* passphrase, - bool newWallet, uint64_t restore_height, uint64_t kdf_rounds) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->createWalletFromPolyseed(std::string(path), - std::string(password), - static_cast(nettype), - std::string(mnemonic), - std::string(passphrase), - newWallet, - restore_height, - kdf_rounds); - DEBUG_END() -} - - -bool WOWNERO_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return wm->closeWallet(wallet, store); - DEBUG_END() -} - -bool WOWNERO_WalletManager_walletExists(void* wm_ptr, const char* path) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->walletExists(std::string(path)); - DEBUG_END() -} - -// virtual bool verifyWalletPassword(const std::string &keys_file_name, const std::string &password, bool no_spend_key, uint64_t kdf_rounds = 1) const = 0; -bool WOWNERO_WalletManager_verifyWalletPassword(void* wm_ptr, const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->verifyWalletPassword(std::string(keys_file_name), std::string(password), no_spend_key, kdf_rounds); - DEBUG_END() -} -// virtual bool queryWalletDevice(Wallet::Device& device_type, const std::string &keys_file_name, const std::string &password, uint64_t kdf_rounds = 1) const = 0; -// bool WOWNERO_WalletManager_queryWalletDevice(void* wm_ptr, int device_type, const char* keys_file_name, const char* password, uint64_t kdf_rounds) { -// Monero::WalletManager *wm = reinterpret_cast(wm_ptr); -// return wm->queryWalletDevice(reinterpret_cast(device_type), std::string(keys_file_name), std::string(password), kdf_rounds); -// } -// virtual std::vector findWallets(const std::string &path) = 0; -const char* WOWNERO_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return vectorToString(wm->findWallets(std::string(path)), std::string(separator)); - DEBUG_END() -} - - -const char* WOWNERO_WalletManager_errorString(void* wm_ptr) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - std::string str = wm->errorString(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -void WOWNERO_WalletManager_setDaemonAddress(void* wm_ptr, const char* address) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->setDaemonAddress(std::string(address)); - DEBUG_END() -} - -bool WOWNERO_WalletManager_setProxy(void* wm_ptr, const char* address) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->setProxy(std::string(address)); - DEBUG_END() -} - - -// virtual bool connected(uint32_t *version = NULL) = 0; -// virtual uint64_t blockchainHeight() = 0; -uint64_t WOWNERO_WalletManager_blockchainHeight(void* wm_ptr) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->blockchainHeight(); - DEBUG_END() -} -// virtual uint64_t blockchainTargetHeight() = 0; -uint64_t WOWNERO_WalletManager_blockchainTargetHeight(void* wm_ptr) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->blockchainTargetHeight(); - DEBUG_END() -} -// virtual uint64_t networkDifficulty() = 0; -uint64_t WOWNERO_WalletManager_networkDifficulty(void* wm_ptr) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->networkDifficulty(); - DEBUG_END() -} -// virtual double miningHashRate() = 0; -double WOWNERO_WalletManager_miningHashRate(void* wm_ptr) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->miningHashRate(); - DEBUG_END() -} -// virtual uint64_t blockTarget() = 0; -uint64_t WOWNERO_WalletManager_blockTarget(void* wm_ptr) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->blockTarget(); - DEBUG_END() -} -// virtual bool isMining() = 0; -bool WOWNERO_WalletManager_isMining(void* wm_ptr) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->isMining(); - DEBUG_END() -} -// virtual bool startMining(const std::string &address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true) = 0; -bool WOWNERO_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->startMining(std::string(address), threads, backgroundMining, ignoreBattery); - DEBUG_END() -} -// virtual bool stopMining() = 0; -bool WOWNERO_WalletManager_stopMining(void* wm_ptr, const char* address) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - return wm->stopMining(); - DEBUG_END() -} -// virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0; -const char* WOWNERO_WalletManager_resolveOpenAlias(void* wm_ptr, const char* address, bool dnssec_valid) { - DEBUG_START() - Monero::WalletManager *wm = reinterpret_cast(wm_ptr); - std::string str = wm->resolveOpenAlias(std::string(address), dnssec_valid); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -// WalletManagerFactory - -void* WOWNERO_WalletManagerFactory_getWalletManager() { - DEBUG_START() - Monero::WalletManager *wm = Monero::WalletManagerFactory::getWalletManager(); - return reinterpret_cast(wm); - DEBUG_END() -} - -void WOWNERO_WalletManagerFactory_setLogLevel(int level) { - DEBUG_START() - Monero::WalletManagerFactory::setLogLevel(level); - DEBUG_END() -} - -void WOWNERO_WalletManagerFactory_setLogCategories(const char* categories) { - DEBUG_START() - Monero::WalletManagerFactory::setLogCategories(std::string(categories)); - DEBUG_END() -} - -// DEBUG functions - -// As it turns out we need a bit more functions to make sure that the library is working. -// 0) void -// 1) bool -// 2) int -// 3) uint64_t -// 4) void* -// 5) const char* - -void WOWNERO_DEBUG_test0() { - return; -} - -bool WOWNERO_DEBUG_test1(bool x) { - return x; -} - -int WOWNERO_DEBUG_test2(int x) { - return x; -} - -uint64_t WOWNERO_DEBUG_test3(uint64_t x) { - return x; -} - -void* WOWNERO_DEBUG_test4(uint64_t x) { - int y = x; - return reinterpret_cast(&y); -} - -const char* WOWNERO_DEBUG_test5() { - const char *text = "This is a const char* text"; - return text; -} - -const char* WOWNERO_DEBUG_test5_std() { - std::string text ("This is a std::string text"); - const char *text2 = "This is a text"; - return text2; -} - -bool WOWNERO_DEBUG_isPointerNull(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - return (wallet != NULL); - DEBUG_END() -} - -// cake wallet world -// TODO(mrcyjanek): https://api.dart.dev/stable/3.3.3/dart-ffi/Pointer/fromFunction.html -// callback to dart should be possible..? I mean why not? But I need to -// wait for other implementation (Go preferably) to see if this approach -// will work as expected. -struct WOWNERO_cw_WalletListener; -struct WOWNERO_cw_WalletListener : Monero::WalletListener -{ - uint64_t m_height; - bool m_need_to_refresh; - bool m_new_transaction; - - WOWNERO_cw_WalletListener() - { - m_height = 0; - m_need_to_refresh = false; - m_new_transaction = false; - } - - void moneySpent(const std::string &txId, uint64_t amount) - { - m_new_transaction = true; - } - - void moneyReceived(const std::string &txId, uint64_t amount) - { - m_new_transaction = true; - } - - void unconfirmedMoneyReceived(const std::string &txId, uint64_t amount) - { - m_new_transaction = true; - } - - void newBlock(uint64_t height) - { - m_height = height; - } - - void updated() - { - m_new_transaction = true; - } - - void refreshed() - { - m_need_to_refresh = true; - } - - - void cw_resetNeedToRefresh() - { - m_need_to_refresh = false; - } - - bool cw_isNeedToRefresh() - { - return m_need_to_refresh; - } - - bool cw_isNewTransactionExist() - { - return m_new_transaction; - } - - void cw_resetIsNewTransactionExist() - { - m_new_transaction = false; - } - - uint64_t cw_height() - { - return m_height; - } - - void refreshed(bool success) {}; -}; - -void* WOWNERO_cw_getWalletListener(void* wallet_ptr) { - DEBUG_START() - Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); - WOWNERO_cw_WalletListener *listener = new WOWNERO_cw_WalletListener(); - wallet->setListener(listener); - return reinterpret_cast(listener); - DEBUG_END() -} - -void WOWNERO_cw_WalletListener_resetNeedToRefresh(void* cw_walletListener_ptr) { - DEBUG_START() - WOWNERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); - listener->cw_resetNeedToRefresh(); - DEBUG_END() -} - -bool WOWNERO_cw_WalletListener_isNeedToRefresh(void* cw_walletListener_ptr) { - DEBUG_START() - WOWNERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); - return listener->cw_isNeedToRefresh(); - DEBUG_END() -}; - -bool WOWNERO_cw_WalletListener_isNewTransactionExist(void* cw_walletListener_ptr) { - DEBUG_START() - WOWNERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); - return listener->cw_isNeedToRefresh(); - DEBUG_END() -}; - -void WOWNERO_cw_WalletListener_resetIsNewTransactionExist(void* cw_walletListener_ptr) { - DEBUG_START() - WOWNERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); - listener->cw_isNeedToRefresh(); - DEBUG_END() -}; - -uint64_t WOWNERO_cw_WalletListener_height(void* cw_walletListener_ptr) { - DEBUG_START() - WOWNERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); - return listener->cw_isNeedToRefresh(); - DEBUG_END() -}; - -// 14-word polyseed compat -// wow was really quick to implement polyseed support (aka wownero-seed), which -// results in this maintenance burden we have to go through. -// -// Code is borrowed from -// https://github.com/cypherstack/flutter_libmonero/blob/2c684cedba6c3d9353c7ea748cadb5a246008027/cw_wownero/ios/Classes/wownero_api.cpp#L240 -// this code slightly goes against the way of being simple -void* WOWNERO_deprecated_restore14WordSeed(char *path, char *password, char *seed, int32_t networkType) { - DEBUG_START() - Monero::WalletManager *walletManager = Monero::WalletManagerFactory::getWalletManager(); - try { - Monero::NetworkType _networkType = static_cast(networkType); - - // 14 word seeds /* - wownero_seed wow_seed(seed, "wownero"); - - std::stringstream seed_stream; - seed_stream << wow_seed; - std::string seed_str = seed_stream.str(); - - std::stringstream key_stream; - key_stream << wow_seed.key(); - std::string spendKey = key_stream.str(); - - uint64_t restoreHeight = wow_seed.blockheight(); - - Monero::Wallet *wallet = walletManager->createDeterministicWalletFromSpendKey( - std::string(path), - std::string(password), - "English", - static_cast(_networkType), - (uint64_t)restoreHeight, - spendKey, - 1); - wallet->setCacheAttribute("cake.seed", seed_str); - return reinterpret_cast(wallet); - } catch (...) { - // fallback code so wallet->status() returns at least something.. eh.. - Monero::Wallet *wallet = walletManager->recoveryWallet( - "/", - "", - "invalid mnemonic", - static_cast(networkType), - 0, - 1, - ""); - return reinterpret_cast(wallet); - } - DEBUG_END() -} - -uint64_t WOWNERO_deprecated_14WordSeedHeight(char *seed) { - DEBUG_START() - try { - wownero_seed wow_seed(seed, "wownero"); - return wow_seed.blockheight(); - } catch(...) { - return 1; - } - DEBUG_END() -} - -void* WOWNERO_deprecated_create14WordSeed(char *path, char *password, char *language, int32_t networkType) { - DEBUG_START() - Monero::NetworkType _networkType = static_cast(networkType); - Monero::WalletManager *walletManager = Monero::WalletManagerFactory::getWalletManager(); - - // 14 word seeds /* - time_t time = std::time(nullptr); - wownero_seed wow_seed(time, "wownero"); - - std::stringstream seed_stream; - seed_stream << wow_seed; - std::string seed = seed_stream.str(); - - std::stringstream key_stream; - key_stream << wow_seed.key(); - std::string spendKey = key_stream.str(); - - uint64_t restoreHeight = wow_seed.blockheight(); - - Monero::Wallet *wallet = walletManager->createDeterministicWalletFromSpendKey( - std::string(path), - std::string(password), - std::string(language), - static_cast(_networkType), - (uint64_t)restoreHeight, - spendKey, - 1); - wallet->setCacheAttribute("cake.seed", seed); - return reinterpret_cast(wallet); - DEBUG_END() -} - -const char* WOWNERO_checksum_wallet2_api_c_h() { - return WOWNERO_wallet2_api_c_h_sha256; -} -const char* WOWNERO_checksum_wallet2_api_c_cpp() { - return WOWNERO_wallet2_api_c_cpp_sha256; -} -const char* WOWNERO_checksum_wallet2_api_c_exp() { - return WOWNERO_wallet2_api_c_exp_sha256; -} -// i hate windows - -void WOWNERO_free(void* ptr) { - free(ptr); -} - -#ifdef __cplusplus -} -#endif diff --git a/wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h b/wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h deleted file mode 100644 index f58adcd..0000000 --- a/wownero_libwallet2_api_c/src/main/cpp/wallet2_api_c.h +++ /dev/null @@ -1,1019 +0,0 @@ -/* -#include - -#define LOG_TAG "[NDK]" -#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__) -#define LOGW(...) __android_log_print(ANDROID_LOG_WARN,LOG_TAG,__VA_ARGS__) -#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__) -*/ -#include -#include -#include -#include - -#ifdef __cplusplus -extern "C" -{ -#endif - -#ifdef __MINGW32__ - #define ADDAPI __declspec(dllexport) -#else - #define ADDAPI __attribute__((__visibility__("default"))) -#endif - -// namespace Monero { -// enum NetworkType : uint8_t { -// MAINNET = 0, -const int NetworkType_MAINNET = 0; -// TESTNET, -const int NetworkType_TESTNET = 1; -// STAGENET -const int NetworkType_STAGENET = 2; -// }; -// namespace Utils { -// bool isAddressLocal(const std::string &hostaddr); -// void onStartup(); -// } -// template -// class optional { -// public: -// optional(): set(false) {} -// optional(const T &t): t(t), set(true) {} -// const T &operator*() const { return t; } -// T &operator*() { return t; } -// operator bool() const { return set; } -// private: -// T t; -// bool set; -// }; - -// struct PendingTransaction -// { -// enum Status { -// Status_Ok, -const int PendingTransactionStatus_Ok = 0; -// Status_Error, -const int PendingTransactionStatus_Error = 1; -// Status_Critical -const int PendingTransactionStatus_Critical = 2; -// }; -// enum Priority { -// Priority_Default = 0, -const int Priority_Default = 0; -// Priority_Low = 1, -const int Priority_Low = 1; -// Priority_Medium = 2, -const int Priority_Medium = 2; -// Priority_High = 3, -const int Priority_High = 3; -// Priority_Last -const int Priority_Last = 4; -// }; -// virtual ~PendingTransaction() = 0; -// virtual int status() const = 0; -extern ADDAPI int WOWNERO_PendingTransaction_status(void* pendingTx_ptr); -// virtual std::string errorString() const = 0; -extern ADDAPI const char* WOWNERO_PendingTransaction_errorString(void* pendingTx_ptr); -// virtual bool commit(const std::string &filename = "", bool overwrite = false) = 0; -extern ADDAPI bool WOWNERO_PendingTransaction_commit(void* pendingTx_ptr, const char* filename, bool overwrite); -// virtual uint64_t amount() const = 0; -extern ADDAPI uint64_t WOWNERO_PendingTransaction_amount(void* pendingTx_ptr); -// virtual uint64_t dust() const = 0; -extern ADDAPI uint64_t WOWNERO_PendingTransaction_dust(void* pendingTx_ptr); -// virtual uint64_t fee() const = 0; -extern ADDAPI uint64_t WOWNERO_PendingTransaction_fee(void* pendingTx_ptr); -// virtual std::vector txid() const = 0; -extern ADDAPI const char* WOWNERO_PendingTransaction_txid(void* pendingTx_ptr, const char* separator); -// virtual uint64_t txCount() const = 0; -extern ADDAPI uint64_t WOWNERO_PendingTransaction_txCount(void* pendingTx_ptr); -// virtual std::vector subaddrAccount() const = 0; -extern ADDAPI const char* WOWNERO_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator); -// virtual std::vector> subaddrIndices() const = 0; -extern ADDAPI const char* WOWNERO_PendingTransaction_subaddrIndices(void* pendingTx_ptr, const char* separator); -// virtual std::string multisigSignData() = 0; -extern ADDAPI const char* WOWNERO_PendingTransaction_multisigSignData(void* pendingTx_ptr); -// virtual void signMultisigTx() = 0; -extern ADDAPI void WOWNERO_PendingTransaction_signMultisigTx(void* pendingTx_ptr); -// virtual std::vector signersKeys() const = 0; -extern ADDAPI const char* WOWNERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator); -// virtual std::vector hex() const = 0; -extern ADDAPI const char* WOWNERO_PendingTransaction_hex(void* pendingTx_ptr, const char* separator); -// virtual std::vector txKey() const = 0; -// extern ADDAPI const char* WOWNERO_PendingTransaction_txHex(void* pendingTx_ptr, const char* separator); -// }; - -// struct UnsignedTransaction -// { -// enum Status { -// Status_Ok, -const int UnsignedTransactionStatus_Ok = 0; -// Status_Error, -const int UnsignedTransactionStatus_Error = 1; -// Status_Critical -const int UnsignedTransactionStatus_Critical = 2; -// }; -// virtual ~UnsignedTransaction() = 0; -// virtual int status() const = 0; -extern ADDAPI int WOWNERO_UnsignedTransaction_status(void* unsignedTx_ptr); -// virtual std::string errorString() const = 0; -extern ADDAPI const char* WOWNERO_UnsignedTransaction_errorString(void* unsignedTx_ptr); -// virtual std::vector amount() const = 0; -extern ADDAPI const char* WOWNERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator); -// virtual std::vector fee() const = 0; -extern ADDAPI const char* WOWNERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator); -// virtual std::vector mixin() const = 0; -extern ADDAPI const char* WOWNERO_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator); -// virtual std::string confirmationMessage() const = 0; -extern ADDAPI const char* WOWNERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr); -// virtual std::vector paymentId() const = 0; -extern ADDAPI const char* WOWNERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator); -// virtual std::vector recipientAddress() const = 0; -extern ADDAPI const char* WOWNERO_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator); -// virtual uint64_t minMixinCount() const = 0; -extern ADDAPI uint64_t WOWNERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr); -// virtual uint64_t txCount() const = 0; -extern ADDAPI uint64_t WOWNERO_UnsignedTransaction_txCount(void* unsignedTx_ptr); -// virtual bool sign(const std::string &signedFileName) = 0; -extern ADDAPI bool WOWNERO_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName); -// }; -// struct TransactionInfo -// { -// enum Direction { -// Direction_In, -const int TransactionInfoDirection_In = 0; -// Direction_Out -const int TransactionInfoDirection_Out = 1; -// }; -// struct Transfer { -// Transfer(uint64_t _amount, const std::string &address); -// const uint64_t amount; -// const std::string address; -// }; -// virtual ~TransactionInfo() = 0; -// virtual int direction() const = 0; -extern ADDAPI int WOWNERO_TransactionInfo_direction(void* txInfo_ptr); -// virtual bool isPending() const = 0; -extern ADDAPI bool WOWNERO_TransactionInfo_isPending(void* txInfo_ptr); -// virtual bool isFailed() const = 0; -extern ADDAPI bool WOWNERO_TransactionInfo_isFailed(void* txInfo_ptr); -// virtual bool isCoinbase() const = 0; -extern ADDAPI bool WOWNERO_TransactionInfo_isCoinbase(void* txInfo_ptr); -// virtual uint64_t amount() const = 0; -extern ADDAPI uint64_t WOWNERO_TransactionInfo_amount(void* txInfo_ptr); -// virtual uint64_t fee() const = 0; -extern ADDAPI uint64_t WOWNERO_TransactionInfo_fee(void* txInfo_ptr); -// virtual uint64_t blockHeight() const = 0; -extern ADDAPI uint64_t WOWNERO_TransactionInfo_blockHeight(void* txInfo_ptr); -// virtual std::string description() const = 0; -extern ADDAPI const char* WOWNERO_TransactionInfo_description(void* txInfo_ptr); -// virtual std::set subaddrIndex() const = 0; -extern ADDAPI const char* WOWNERO_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator); -// virtual uint32_t subaddrAccount() const = 0; -extern ADDAPI uint32_t WOWNERO_TransactionInfo_subaddrAccount(void* txInfo_ptr); -// virtual std::string label() const = 0; -extern ADDAPI const char* WOWNERO_TransactionInfo_label(void* txInfo_ptr); -// virtual uint64_t confirmations() const = 0; -extern ADDAPI uint64_t WOWNERO_TransactionInfo_confirmations(void* txInfo_ptr); -// virtual uint64_t unlockTime() const = 0; -extern ADDAPI uint64_t WOWNERO_TransactionInfo_unlockTime(void* txInfo_ptr); -// virtual std::string hash() const = 0; -extern ADDAPI const char* WOWNERO_TransactionInfo_hash(void* txInfo_ptr); -// virtual std::time_t timestamp() const = 0; -extern ADDAPI uint64_t WOWNERO_TransactionInfo_timestamp(void* txInfo_ptr); -// virtual std::string paymentId() const = 0; -extern ADDAPI const char* WOWNERO_TransactionInfo_paymentId(void* txInfo_ptr); -// virtual const std::vector & transfers() const = 0; -extern ADDAPI int WOWNERO_TransactionInfo_transfers_count(void* txInfo_ptr); -extern ADDAPI uint64_t WOWNERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index); -extern ADDAPI const char* WOWNERO_TransactionInfo_transfers_address(void* txInfo_ptr, int address); -// }; -// struct TransactionHistory -// { -// virtual ~TransactionHistory() = 0; -// virtual int count() const = 0; -extern ADDAPI int WOWNERO_TransactionHistory_count(void* txHistory_ptr); -// virtual TransactionInfo * transaction(int index) const = 0; -extern ADDAPI void* WOWNERO_TransactionHistory_transaction(void* txHistory_ptr, int index); -// virtual TransactionInfo * transaction(const std::string &id) const = 0; -extern ADDAPI void* WOWNERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id); -// virtual std::vector getAll() const = 0; -// virtual void refresh() = 0; -extern ADDAPI void WOWNERO_TransactionHistory_refresh(void* txHistory_ptr); -// virtual void setTxNote(const std::string &txid, const std::string ¬e) = 0; -extern ADDAPI void WOWNERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note); -// }; -// struct AddressBookRow { -// public: -// AddressBookRow(std::size_t _rowId, const std::string &_address, const std::string &_paymentId, const std::string &_description): -// m_rowId(_rowId), -// m_address(_address), -// m_paymentId(_paymentId), -// m_description(_description) {} - -// private: -// std::size_t m_rowId; -// std::string m_address; -// std::string m_paymentId; -// std::string m_description; -// public: -// std::string extra; -extern ADDAPI const char* WOWNERO_AddressBookRow_extra(void* addressBookRow_ptr); -// std::string getAddress() const {return m_address;} -extern ADDAPI const char* WOWNERO_AddressBookRow_getAddress(void* addressBookRow_ptr); -// std::string getDescription() const {return m_description;} -extern ADDAPI const char* WOWNERO_AddressBookRow_getDescription(void* addressBookRow_ptr); -// std::string getPaymentId() const {return m_paymentId;} -extern ADDAPI const char* WOWNERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr); -// std::size_t getRowId() const {return m_rowId;} -extern ADDAPI size_t WOWNERO_AddressBookRow_getRowId(void* addressBookRow_ptr); -// }; -// struct AddressBook -// { -// enum ErrorCode { -// Status_Ok, -const int AddressBookErrorCodeStatus_Ok = 0; -// General_Error, -const int AddressBookErrorCodeGeneral_Error = 1; -// Invalid_Address, -const int AddressBookErrorCodeInvalid_Address = 2; -// Invalid_Payment_Id -const int AddressBookErrorCodeInvalidPaymentId = 3; -// }; -// virtual ~AddressBook() = 0; -// virtual std::vector getAll() const = 0; -extern ADDAPI int WOWNERO_AddressBook_getAll_size(void* addressBook_ptr); -extern ADDAPI void* WOWNERO_AddressBook_getAll_byIndex(void* addressBook_ptr, int index); -// virtual bool addRow(const std::string &dst_addr , const std::string &payment_id, const std::string &description) = 0; -extern ADDAPI bool WOWNERO_AddressBook_addRow(void* addressBook_ptr, const char* dst_addr , const char* payment_id, const char* description); -// virtual bool deleteRow(std::size_t rowId) = 0; -extern ADDAPI bool WOWNERO_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId); -// virtual bool setDescription(std::size_t index, const std::string &description) = 0; -extern ADDAPI bool WOWNERO_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description); -// virtual void refresh() = 0; -extern ADDAPI void WOWNERO_AddressBook_refresh(void* addressBook_ptr); -// virtual std::string errorString() const = 0; -extern ADDAPI const char* WOWNERO_AddressBook_errorString(void* addressBook_ptr); -// virtual int errorCode() const = 0; -extern ADDAPI int WOWNERO_AddressBook_errorCode(void* addressBook_ptr); -// virtual int lookupPaymentID(const std::string &payment_id) const = 0; -extern ADDAPI int WOWNERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id); -// }; -// struct CoinsInfo -// { -// virtual ~CoinsInfo() = 0; -// virtual uint64_t blockHeight() const = 0; -extern ADDAPI uint64_t WOWNERO_CoinsInfo_blockHeight(void* coinsInfo_ptr); -// virtual std::string hash() const = 0; -extern ADDAPI const char* WOWNERO_CoinsInfo_hash(void* coinsInfo_ptr); -// virtual size_t internalOutputIndex() const = 0; -extern ADDAPI size_t WOWNERO_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr); -// virtual uint64_t globalOutputIndex() const = 0; -extern ADDAPI uint64_t WOWNERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr); -// virtual bool spent() const = 0; -extern ADDAPI bool WOWNERO_CoinsInfo_spent(void* coinsInfo_ptr); -// virtual bool frozen() const = 0; -extern ADDAPI bool WOWNERO_CoinsInfo_frozen(void* coinsInfo_ptr); -// virtual uint64_t spentHeight() const = 0; -extern ADDAPI uint64_t WOWNERO_CoinsInfo_spentHeight(void* coinsInfo_ptr); -// virtual uint64_t amount() const = 0; -extern ADDAPI uint64_t WOWNERO_CoinsInfo_amount(void* coinsInfo_ptr); -// virtual bool rct() const = 0; -extern ADDAPI bool WOWNERO_CoinsInfo_rct(void* coinsInfo_ptr); -// virtual bool keyImageKnown() const = 0; -extern ADDAPI bool WOWNERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr); -// virtual size_t pkIndex() const = 0; -extern ADDAPI size_t WOWNERO_CoinsInfo_pkIndex(void* coinsInfo_ptr); -// virtual uint32_t subaddrIndex() const = 0; -extern ADDAPI uint32_t WOWNERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr); -// virtual uint32_t subaddrAccount() const = 0; -extern ADDAPI uint32_t WOWNERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr); -// virtual std::string address() const = 0; -extern ADDAPI const char* WOWNERO_CoinsInfo_address(void* coinsInfo_ptr); -// virtual std::string addressLabel() const = 0; -extern ADDAPI const char* WOWNERO_CoinsInfo_addressLabel(void* coinsInfo_ptr); -// virtual std::string keyImage() const = 0; -extern ADDAPI const char* WOWNERO_CoinsInfo_keyImage(void* coinsInfo_ptr); -// virtual uint64_t unlockTime() const = 0; -extern ADDAPI uint64_t WOWNERO_CoinsInfo_unlockTime(void* coinsInfo_ptr); -// virtual bool unlocked() const = 0; -extern ADDAPI bool WOWNERO_CoinsInfo_unlocked(void* coinsInfo_ptr); -// virtual std::string pubKey() const = 0; -extern ADDAPI const char* WOWNERO_CoinsInfo_pubKey(void* coinsInfo_ptr); -// virtual bool coinbase() const = 0; -extern ADDAPI bool WOWNERO_CoinsInfo_coinbase(void* coinsInfo_ptr); -// virtual std::string description() const = 0; -extern ADDAPI const char* WOWNERO_CoinsInfo_description(void* coinsInfo_ptr); -// }; -// struct Coins -// { -// virtual ~Coins() = 0; -// virtual int count() const = 0; -extern ADDAPI int WOWNERO_Coins_count(void* coins_ptr); -// virtual CoinsInfo * coin(int index) const = 0; -extern ADDAPI void* WOWNERO_Coins_coin(void* coins_ptr, int index); -// virtual std::vector getAll() const = 0; -extern ADDAPI int WOWNERO_Coins_getAll_size(void* coins_ptr); -extern ADDAPI void* WOWNERO_Coins_getAll_byIndex(void* coins_ptr, int index); -// virtual void refresh() = 0; -extern ADDAPI void WOWNERO_Coins_refresh(void* coins_ptr); -// virtual void setFrozen(std::string public_key) = 0; -extern ADDAPI void WOWNERO_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key); -// virtual void setFrozen(int index) = 0; -extern ADDAPI void WOWNERO_Coins_setFrozen(void* coins_ptr, int index); -// virtual void thaw(int index) = 0; -extern ADDAPI void WOWNERO_Coins_thaw(void* coins_ptr, int index); -// virtual void thaw(std::string public_key) = 0; -extern ADDAPI void WOWNERO_Coins_thawByPublicKey(void* coins_ptr, const char* public_key); -// virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0; -extern ADDAPI bool WOWNERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight); -// virtual void setDescription(const std::string &public_key, const std::string &description) = 0; -extern ADDAPI void WOWNERO_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description); -// }; -// struct SubaddressRow { -// public: -// SubaddressRow(std::size_t _rowId, const std::string &_address, const std::string &_label): -// m_rowId(_rowId), -// m_address(_address), -// m_label(_label) {} - -// private: -// std::size_t m_rowId; -// std::string m_address; -// std::string m_label; -// public: -// std::string extra; -extern ADDAPI const char* WOWNERO_SubaddressRow_extra(void* subaddressRow_ptr); -// std::string getAddress() const {return m_address;} -extern ADDAPI const char* WOWNERO_SubaddressRow_getAddress(void* subaddressRow_ptr); -// std::string getLabel() const {return m_label;} -extern ADDAPI const char* WOWNERO_SubaddressRow_getLabel(void* subaddressRow_ptr); -// std::size_t getRowId() const {return m_rowId;} -extern ADDAPI size_t WOWNERO_SubaddressRow_getRowId(void* subaddressRow_ptr); -// }; - -// struct Subaddress -// { -// virtual ~Subaddress() = 0; -// virtual std::vector getAll() const = 0; -extern ADDAPI int WOWNERO_Subaddress_getAll_size(void* subaddress_ptr); -extern ADDAPI void* WOWNERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index); -// virtual void addRow(uint32_t accountIndex, const std::string &label) = 0; -extern ADDAPI void WOWNERO_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label); -// virtual void setLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0; -extern ADDAPI void WOWNERO_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label); -// virtual void refresh(uint32_t accountIndex) = 0; -extern ADDAPI void WOWNERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex); -// }; - -// struct SubaddressAccountRow { -// public: -// SubaddressAccountRow(std::size_t _rowId, const std::string &_address, const std::string &_label, const std::string &_balance, const std::string &_unlockedBalance): -// m_rowId(_rowId), -// m_address(_address), -// m_label(_label), -// m_balance(_balance), -// m_unlockedBalance(_unlockedBalance) {} - -// private: -// std::size_t m_rowId; -// std::string m_address; -// std::string m_label; -// std::string m_balance; -// std::string m_unlockedBalance; -// public: -// std::string extra; -extern ADDAPI const char* WOWNERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr); -// std::string getAddress() const {return m_address;} -extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr); -// std::string getLabel() const {return m_label;} -extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr); -// std::string getBalance() const {return m_balance;} -extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr); -// std::string getUnlockedBalance() const {return m_unlockedBalance;} -extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr); -// std::size_t getRowId() const {return m_rowId;} -extern ADDAPI size_t WOWNERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr); -// }; - -// struct SubaddressAccount -// { -// virtual ~SubaddressAccount() = 0; -// virtual std::vector getAll() const = 0; -extern ADDAPI int WOWNERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr); -extern ADDAPI void* WOWNERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index); -// virtual void addRow(const std::string &label) = 0; -extern ADDAPI void WOWNERO_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label); -// virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0; -extern ADDAPI void WOWNERO_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label); -// virtual void refresh() = 0; -extern ADDAPI void WOWNERO_SubaddressAccount_refresh(void* subaddressAccount_ptr); -// }; - -// struct MultisigState { -// MultisigState() : isMultisig(false), isReady(false), threshold(0), total(0) {} - -// bool isMultisig; -extern ADDAPI bool WOWNERO_MultisigState_isMultisig(void* multisigState_ptr); -// bool isReady; -extern ADDAPI bool WOWNERO_MultisigState_isReady(void* multisigState_ptr); -// uint32_t threshold; -extern ADDAPI uint32_t WOWNERO_MultisigState_threshold(void* multisigState_ptr); -// uint32_t total; -extern ADDAPI uint32_t WOWNERO_MultisigState_total(void* multisigState_ptr); -// }; - - -// struct DeviceProgress { -// DeviceProgress(): m_progress(0), m_indeterminate(false) {} -// DeviceProgress(double progress, bool indeterminate=false): m_progress(progress), m_indeterminate(indeterminate) {} - -// virtual double progress() const { return m_progress; } -extern ADDAPI bool WOWNERO_DeviceProgress_progress(void* deviceProgress_ptr); -// virtual bool indeterminate() const { return m_indeterminate; } -extern ADDAPI bool WOWNERO_DeviceProgress_indeterminate(void* deviceProgress_ptr); - -// protected: -// double m_progress; -// bool m_indeterminate; -// }; - -// struct Wallet; -// struct WalletListener -// { -// virtual ~WalletListener() = 0; -// virtual void moneySpent(const std::string &txId, uint64_t amount) = 0; -// virtual void moneyReceived(const std::string &txId, uint64_t amount) = 0; -// virtual void unconfirmedMoneyReceived(const std::string &txId, uint64_t amount) = 0; -// virtual void newBlock(uint64_t height) = 0; -// virtual void updated() = 0; -// virtual void refreshed() = 0; -// virtual void onDeviceButtonRequest(uint64_t code) { (void)code; } -// virtual void onDeviceButtonPressed() { } -// virtual optional onDevicePinRequest() { -// throw std::runtime_error("Not supported"); -// } -// virtual optional onDevicePassphraseRequest(bool & on_device) { -// on_device = true; -// return optional(); -// } -// virtual void onDeviceProgress(const DeviceProgress & event) { (void)event; }; -// virtual void onSetWallet(Wallet * wallet) { (void)wallet; }; -// }; -// struct Wallet -// { -// enum Device { -// Device_Software = 0, -const int WalletDevice_Software = 0; -// Device_Ledger = 1, -const int WalletDevice_Ledger = 1; -// Device_Trezor = 2 -const int WalletDevice_Trezor = 2; -// }; -// enum Status { -// Status_Ok, -const int WalletStatus_Ok = 0; -// Status_Error, -const int WalletStatus_Error = 1; -// Status_Critical -const int WalletStatus_Critical = 2; -// }; -// enum ConnectionStatus { -// ConnectionStatus_Disconnected, -const int WalletConnectionStatus_Disconnected = 0; -// ConnectionStatus_Connected, -const int WalletConnectionStatus_Connected = 1; -// ConnectionStatus_WrongVersion -const int WalletConnectionStatus_WrongVersion = 2; -// }; -// enum BackgroundSyncType { -// BackgroundSync_Off = 0, -const int WalletBackgroundSync_Off = 0; -// BackgroundSync_ReusePassword = 1, -const int WalletBackgroundSync_ReusePassword = 1; -// BackgroundSync_CustomPassword = 2 -const int BackgroundSync_CustomPassword = 2; -// }; -// virtual ~Wallet() = 0; -// virtual std::string seed(const std::string& seed_offset = "") const = 0; -extern ADDAPI const char* WOWNERO_Wallet_seed(void* wallet_ptr, const char* seed_offset); -// virtual std::string getSeedLanguage() const = 0; -extern ADDAPI const char* WOWNERO_Wallet_getSeedLanguage(void* wallet_ptr); -// virtual void setSeedLanguage(const std::string &arg) = 0; -extern ADDAPI void WOWNERO_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg); -// virtual int status() const = 0; -extern ADDAPI int WOWNERO_Wallet_status(void* wallet_ptr); -// virtual std::string errorString() const = 0; -extern ADDAPI const char* WOWNERO_Wallet_errorString(void* wallet_ptr); -// virtual void statusWithErrorString(int& status, std::string& errorString) const = 0; -// virtual bool setPassword(const std::string &password) = 0; -extern ADDAPI bool WOWNERO_Wallet_setPassword(void* wallet_ptr, const char* password); -// virtual const std::string& getPassword() const = 0; -extern ADDAPI const char* WOWNERO_Wallet_getPassword(void* wallet_ptr); -// virtual bool setDevicePin(const std::string &pin) { (void)pin; return false; }; -extern ADDAPI bool WOWNERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin); -// virtual bool setDevicePassphrase(const std::string &passphrase) { (void)passphrase; return false; }; -extern ADDAPI bool WOWNERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase); -// virtual std::string address(uint32_t accountIndex = 0, uint32_t addressIndex = 0) const = 0; -extern ADDAPI const char* WOWNERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex); -// std::string mainAddress() const { return address(0, 0); } -// virtual std::string path() const = 0; -extern ADDAPI const char* WOWNERO_Wallet_path(void* wallet_ptr); -// virtual NetworkType nettype() const = 0; -extern ADDAPI int WOWNERO_Wallet_nettype(void* wallet_ptr); -// bool mainnet() const { return nettype() == MAINNET; } -// bool testnet() const { return nettype() == TESTNET; } -// bool stagenet() const { return nettype() == STAGENET; } -// virtual void hardForkInfo(uint8_t &version, uint64_t &earliest_height) const = 0; -// virtual bool useForkRules(uint8_t version, int64_t early_blocks) const = 0; -extern ADDAPI uint8_t WOWNERO_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks); -// virtual std::string integratedAddress(const std::string &payment_id) const = 0; -extern ADDAPI const char* WOWNERO_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id); -// virtual std::string secretViewKey() const = 0; -extern ADDAPI const char* WOWNERO_Wallet_secretViewKey(void* wallet_ptr); -// virtual std::string publicViewKey() const = 0; -extern ADDAPI const char* WOWNERO_Wallet_publicViewKey(void* wallet_ptr); -// virtual std::string secretSpendKey() const = 0; -extern ADDAPI const char* WOWNERO_Wallet_secretSpendKey(void* wallet_ptr); -// virtual std::string publicSpendKey() const = 0; -extern ADDAPI const char* WOWNERO_Wallet_publicSpendKey(void* wallet_ptr); -// virtual std::string publicMultisigSignerKey() const = 0; -extern ADDAPI const char* WOWNERO_Wallet_publicMultisigSignerKey(void* wallet_ptr); -// virtual void stop() = 0; -extern ADDAPI void WOWNERO_Wallet_stop(void* wallet_ptr); -// virtual bool store(const std::string &path) = 0; -extern ADDAPI bool WOWNERO_Wallet_store(void* wallet_ptr, const char* path); -// virtual std::string filename() const = 0; -extern ADDAPI const char* WOWNERO_Wallet_filename(void* wallet_ptr); -// virtual std::string keysFilename() const = 0; -extern ADDAPI const char* WOWNERO_Wallet_keysFilename(void* wallet_ptr); -// virtual bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit = 0, const std::string &daemon_username = "", const std::string &daemon_password = "", bool use_ssl = false, bool lightWallet = false, const std::string &proxy_address = "") = 0; -extern ADDAPI bool WOWNERO_Wallet_init(void* wallet_ptr, const char* daemon_address, uint64_t upper_transaction_size_limit, const char* daemon_username, const char* daemon_password, bool use_ssl, bool lightWallet, const char* proxy_address); -// virtual bool createWatchOnly(const std::string &path, const std::string &password, const std::string &language) const = 0; -extern ADDAPI bool WOWNERO_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language); -// virtual void setRefreshFromBlockHeight(uint64_t refresh_from_block_height) = 0; -extern ADDAPI void WOWNERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height); -// virtual uint64_t getRefreshFromBlockHeight() const = 0; -extern ADDAPI uint64_t WOWNERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr); -// virtual void setRecoveringFromSeed(bool recoveringFromSeed) = 0; -extern ADDAPI void WOWNERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed); -// virtual void setRecoveringFromDevice(bool recoveringFromDevice) = 0; -extern ADDAPI void WOWNERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice); -// virtual void setSubaddressLookahead(uint32_t major, uint32_t minor) = 0; -extern ADDAPI void WOWNERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor); -// virtual bool connectToDaemon() = 0; -extern ADDAPI bool WOWNERO_Wallet_connectToDaemon(void* wallet_ptr); -// virtual ConnectionStatus connected() const = 0; -extern ADDAPI int WOWNERO_Wallet_connected(void* wallet_ptr); -// virtual void setTrustedDaemon(bool arg) = 0; -extern ADDAPI void WOWNERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg); -// virtual bool trustedDaemon() const = 0; -extern ADDAPI bool WOWNERO_Wallet_trustedDaemon(void* wallet_ptr); -// virtual bool setProxy(const std::string &address) = 0; -extern ADDAPI bool WOWNERO_Wallet_setProxy(void* wallet_ptr, const char* address); -// virtual uint64_t balance(uint32_t accountIndex = 0) const = 0; -extern ADDAPI uint64_t WOWNERO_Wallet_balance(void* wallet_ptr, uint32_t accountIndex); -// uint64_t balanceAll() const { -// uint64_t result = 0; -// for (uint32_t i = 0; i < numSubaddressAccounts(); ++i) -// result += balance(i); -// return result; -// } -// virtual uint64_t unlockedBalance(uint32_t accountIndex = 0) const = 0; -extern ADDAPI uint64_t WOWNERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex); -// uint64_t unlockedBalanceAll() const { -// uint64_t result = 0; -// for (uint32_t i = 0; i < numSubaddressAccounts(); ++i) -// result += unlockedBalance(i); -// return result; -// } -// virtual bool watchOnly() const = 0; -// virtual uint64_t viewOnlyBalance(uint32_t accountIndex, const std::vector &key_images = {}) const = 0; -extern ADDAPI uint64_t WOWNERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex); -extern ADDAPI bool WOWNERO_Wallet_watchOnly(void* wallet_ptr); -// virtual bool isDeterministic() const = 0; -extern ADDAPI bool WOWNERO_Wallet_isDeterministic(void* wallet_ptr); -// virtual uint64_t blockChainHeight() const = 0; -extern ADDAPI uint64_t WOWNERO_Wallet_blockChainHeight(void* wallet_ptr); -// virtual uint64_t approximateBlockChainHeight() const = 0; -extern ADDAPI uint64_t WOWNERO_Wallet_approximateBlockChainHeight(void* wallet_ptr); -// virtual uint64_t estimateBlockChainHeight() const = 0; -extern ADDAPI uint64_t WOWNERO_Wallet_estimateBlockChainHeight(void* wallet_ptr); -// virtual uint64_t daemonBlockChainHeight() const = 0; -extern ADDAPI uint64_t WOWNERO_Wallet_daemonBlockChainHeight(void* wallet_ptr); -// virtual uint64_t daemonBlockChainTargetHeight() const = 0; -extern ADDAPI uint64_t WOWNERO_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr); -// virtual bool synchronized() const = 0; -extern ADDAPI bool WOWNERO_Wallet_synchronized(void* wallet_ptr); -// static std::string displayAmount(uint64_t amount); -extern ADDAPI const char* WOWNERO_Wallet_displayAmount(uint64_t amount); -// static uint64_t amountFromString(const std::string &amount); -extern ADDAPI uint64_t WOWNERO_Wallet_amountFromString(const char* amount); -// static uint64_t amountFromDouble(double amount); -extern ADDAPI uint64_t WOWNERO_Wallet_amountFromDouble(double amount); -// static std::string genPaymentId(); -extern ADDAPI const char* WOWNERO_Wallet_genPaymentId(); -// static bool paymentIdValid(const std::string &paiment_id); -extern ADDAPI bool WOWNERO_Wallet_paymentIdValid(const char* paiment_id); -// static bool addressValid(const std::string &str, NetworkType nettype); -extern ADDAPI bool WOWNERO_Wallet_addressValid(const char* str, int nettype); -// static bool addressValid(const std::string &str, bool testnet) // deprecated -// { -// return addressValid(str, testnet ? TESTNET : MAINNET); -// } -extern ADDAPI bool WOWNERO_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype); -extern ADDAPI const char* WOWNERO_Wallet_keyValid_error(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype); -// static bool keyValid(const std::string &secret_key_string, const std::string &address_string, bool isViewKey, NetworkType nettype, std::string &error); -// static bool keyValid(const std::string &secret_key_string, const std::string &address_string, bool isViewKey, bool testnet, std::string &error) // deprecated -// { -// return keyValid(secret_key_string, address_string, isViewKey, testnet ? TESTNET : MAINNET, error); -// } -// static std::string paymentIdFromAddress(const std::string &str, NetworkType nettype); -extern ADDAPI const char* WOWNERO_Wallet_paymentIdFromAddress(const char* strarg, int nettype); -// static std::string paymentIdFromAddress(const std::string &str, bool testnet) // deprecated -// { -// return paymentIdFromAddress(str, testnet ? TESTNET : MAINNET); -// } -// static uint64_t maximumAllowedAmount(); -extern ADDAPI uint64_t WOWNERO_Wallet_maximumAllowedAmount(); -// static void init(const char *argv0, const char *default_log_base_name) { init(argv0, default_log_base_name, "", true); } -// static void init(const char *argv0, const char *default_log_base_name, const std::string &log_path, bool console); -extern ADDAPI void WOWNERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console); -// static void debug(const std::string &category, const std::string &str); -// static void info(const std::string &category, const std::string &str); -// static void warning(const std::string &category, const std::string &str); -// static void error(const std::string &category, const std::string &str); -// virtual void startRefresh() = 0; -// virtual bool getPolyseed(std::string &seed, std::string &passphrase) const = 0; -extern ADDAPI const char* WOWNERO_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase); -// static bool createPolyseed(std::string &seed_words, std::string &err, const std::string &language = "English"); -extern ADDAPI const char* WOWNERO_Wallet_createPolyseed(const char* language); -extern ADDAPI void WOWNERO_Wallet_startRefresh(void* wallet_ptr); -// virtual void pauseRefresh() = 0; -extern ADDAPI void WOWNERO_Wallet_pauseRefresh(void* wallet_ptr); -// virtual bool refresh() = 0; -extern ADDAPI bool WOWNERO_Wallet_refresh(void* wallet_ptr); -// virtual void refreshAsync() = 0; -extern ADDAPI void WOWNERO_Wallet_refreshAsync(void* wallet_ptr); -// virtual bool rescanBlockchain() = 0; -extern ADDAPI bool WOWNERO_Wallet_rescanBlockchain(void* wallet_ptr); -// virtual void rescanBlockchainAsync() = 0; -extern ADDAPI void WOWNERO_Wallet_rescanBlockchainAsync(void* wallet_ptr); -// virtual void setAutoRefreshInterval(int millis) = 0; -extern ADDAPI void WOWNERO_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis); -// virtual int autoRefreshInterval() const = 0; -extern ADDAPI int WOWNERO_Wallet_autoRefreshInterval(void* wallet_ptr); -// virtual void addSubaddressAccount(const std::string& label) = 0; -extern ADDAPI void WOWNERO_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label); -// virtual size_t numSubaddressAccounts() const = 0; -extern ADDAPI size_t WOWNERO_Wallet_numSubaddressAccounts(void* wallet_ptr); -// virtual size_t numSubaddresses(uint32_t accountIndex) const = 0; -extern ADDAPI size_t WOWNERO_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex); -// virtual void addSubaddress(uint32_t accountIndex, const std::string& label) = 0; -extern ADDAPI void WOWNERO_Wallet_addSubaddress(void* wallet_ptr, uint32_t accountIndex, const char* label); -// virtual std::string getSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex) const = 0; -extern ADDAPI const char* WOWNERO_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex); -// virtual void setSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0; -extern ADDAPI void WOWNERO_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label); -// virtual MultisigState multisig() const = 0; -// virtual std::string getMultisigInfo() const = 0; -extern ADDAPI const char* WOWNERO_Wallet_getMultisigInfo(void* wallet_ptr); -// virtual std::string makeMultisig(const std::vector& info, uint32_t threshold) = 0; -// virtual std::string exchangeMultisigKeys(const std::vector &info, const bool force_update_use_with_caution) = 0; -// virtual bool exportMultisigImages(std::string& images) = 0; -// virtual size_t importMultisigImages(const std::vector& images) = 0; -// virtual bool hasMultisigPartialKeyImages() const = 0; -// virtual PendingTransaction* restoreMultisigTransaction(const std::string& signData) = 0; -// virtual PendingTransaction * createTransactionMultDest(const std::vector &dst_addr, const std::string &payment_id, -// optional> amount, uint32_t mixin_count, -// PendingTransaction::Priority = PendingTransaction::Priority_Low, -// uint32_t subaddr_account = 0, -// std::set subaddr_indices = {}) = 0; -extern ADDAPI void* WOWNERO_Wallet_createTransactionMultDest(void* wallet_ptr, const char* dst_addr_list, const char* dst_addr_list_separator, const char* payment_id, - bool amount_sweep_all, const char* amount_list, const char* amount_list_separator, uint32_t mixin_count, - int pendingTransactionPriority, - uint32_t subaddr_account, - const char* preferredInputs, const char* preferredInputs_separator); -// virtual PendingTransaction * createTransaction(const std::string &dst_addr, const std::string &payment_id, -// optional amount, uint32_t mixin_count, -// PendingTransaction::Priority = PendingTransaction::Priority_Low, -// uint32_t subaddr_account = 0, -// std::set subaddr_indices = {}, -// const std::set &preferred_inputs = {) = 0; -extern ADDAPI void* WOWNERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, - uint64_t amount, uint32_t mixin_count, - int pendingTransactionPriority, - uint32_t subaddr_account, - const char* preferredInputs, const char* separator); -// virtual PendingTransaction * createSweepUnmixableTransaction() = 0; -// virtual UnsignedTransaction * loadUnsignedTx(const std::string &unsigned_filename) = 0; -extern ADDAPI void* WOWNERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* unsigned_filename); -// virtual bool submitTransaction(const std::string &fileName) = 0; -extern ADDAPI bool WOWNERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName); -// virtual void disposeTransaction(PendingTransaction * t) = 0; -// virtual uint64_t estimateTransactionFee(const std::vector> &destinations, -// PendingTransaction::Priority priority) const = 0; -// virtual bool hasUnknownKeyImages() const = 0; -extern ADDAPI bool WOWNERO_Wallet_hasUnknownKeyImages(void* wallet_ptr); -// virtual bool exportKeyImages(const std::string &filename, bool all = false) = 0; -extern ADDAPI bool WOWNERO_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all); -// virtual bool importKeyImages(const std::string &filename) = 0; -extern ADDAPI bool WOWNERO_Wallet_importKeyImages(void* wallet_ptr, const char* filename); -// virtual bool exportOutputs(const std::string &filename, bool all = false) = 0; -extern ADDAPI bool WOWNERO_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool all); -// virtual bool importOutputs(const std::string &filename) = 0; -extern ADDAPI bool WOWNERO_Wallet_importOutputs(void* wallet_ptr, const char* filename); -// virtual bool scanTransactions(const std::vector &txids) = 0; -// virtual bool setupBackgroundSync(const BackgroundSyncType background_sync_type, const std::string &wallet_password, const optional &background_cache_password) = 0; -extern ADDAPI bool WOWNERO_Wallet_setupBackgroundSync(void* wallet_ptr, int background_sync_type, const char* wallet_password, const char* background_cache_password); -// virtual BackgroundSyncType getBackgroundSyncType() const = 0; -extern ADDAPI int WOWNERO_Wallet_getBackgroundSyncType(void* wallet_ptr); -// virtual bool startBackgroundSync() = 0; -extern ADDAPI bool WOWNERO_Wallet_startBackgroundSync(void* wallet_ptr); -// virtual bool stopBackgroundSync(const std::string &wallet_password) = 0; -extern ADDAPI bool WOWNERO_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password); -// virtual bool isBackgroundSyncing() const = 0; -extern ADDAPI bool WOWNERO_Wallet_isBackgroundSyncing(void* wallet_ptr); -// virtual bool isBackgroundWallet() const = 0; -extern ADDAPI bool WOWNERO_Wallet_isBackgroundWallet(void* wallet_ptr); -// virtual TransactionHistory * history() = 0; -extern ADDAPI void* WOWNERO_Wallet_history(void* wallet_ptr); -// virtual AddressBook * addressBook() = 0; -extern ADDAPI void* WOWNERO_Wallet_addressBook(void* wallet_ptr); -// virtual Coins * coins() = 0; -extern ADDAPI void* WOWNERO_Wallet_coins(void* wallet_ptr); -// virtual Subaddress * subaddress() = 0; -extern ADDAPI void* WOWNERO_Wallet_subaddress(void* wallet_ptr); -// virtual SubaddressAccount * subaddressAccount() = 0; -extern ADDAPI void* WOWNERO_Wallet_subaddressAccount(void* wallet_ptr); -// virtual void setListener(WalletListener *) = 0; -// virtual uint32_t defaultMixin() const = 0; -extern ADDAPI uint32_t WOWNERO_Wallet_defaultMixin(void* wallet_ptr); -// virtual void setDefaultMixin(uint32_t arg) = 0; -extern ADDAPI void WOWNERO_Wallet_setDefaultMixin(void* wallet_ptr, uint32_t arg); -// virtual bool setCacheAttribute(const std::string &key, const std::string &val) = 0; -extern ADDAPI bool WOWNERO_Wallet_setCacheAttribute(void* wallet_ptr, const char* key, const char* val); -// virtual std::string getCacheAttribute(const std::string &key) const = 0; -extern ADDAPI const char* WOWNERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key); -// virtual bool setUserNote(const std::string &txid, const std::string ¬e) = 0; -extern ADDAPI bool WOWNERO_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note); -// virtual std::string getUserNote(const std::string &txid) const = 0; -extern ADDAPI const char* WOWNERO_Wallet_getUserNote(void* wallet_ptr, const char* txid); -// virtual std::string getTxKey(const std::string &txid) const = 0; -extern ADDAPI const char* WOWNERO_Wallet_getTxKey(void* wallet_ptr, const char* txid); -// virtual bool checkTxKey(const std::string &txid, std::string tx_key, const std::string &address, uint64_t &received, bool &in_pool, uint64_t &confirmations) = 0; -// virtual std::string getTxProof(const std::string &txid, const std::string &address, const std::string &message) const = 0; -// virtual bool checkTxProof(const std::string &txid, const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &received, bool &in_pool, uint64_t &confirmations) = 0; -// virtual std::string getSpendProof(const std::string &txid, const std::string &message) const = 0; -// virtual bool checkSpendProof(const std::string &txid, const std::string &message, const std::string &signature, bool &good) const = 0; -// virtual std::string getReserveProof(bool all, uint32_t account_index, uint64_t amount, const std::string &message) const = 0; -// virtual bool checkReserveProof(const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &total, uint64_t &spent) const = 0; -// virtual std::string signMessage(const std::string &message, const std::string &address = "") = 0; -extern ADDAPI const char* WOWNERO_Wallet_signMessage(void* wallet_ptr, const char* message, const char* address); -// virtual bool verifySignedMessage(const std::string &message, const std::string &addres, const std::string &signature) const = 0; -extern ADDAPI bool WOWNERO_Wallet_verifySignedMessage(void* wallet_ptr, const char* message, const char* address, const char* signature); -// virtual std::string signMultisigParticipant(const std::string &message) const = 0; -// virtual bool verifyMessageWithPublicKey(const std::string &message, const std::string &publicKey, const std::string &signature) const = 0; -// virtual bool parse_uri(const std::string &uri, std::string &address, std::string &payment_id, uint64_t &amount, std::string &tx_description, std::string &recipient_name, std::vector &unknown_parameters, std::string &error) = 0; -// virtual std::string make_uri(const std::string &address, const std::string &payment_id, uint64_t amount, const std::string &tx_description, const std::string &recipient_name, std::string &error) const = 0; -// virtual std::string getDefaultDataDir() const = 0; -// virtual bool rescanSpent() = 0; -extern ADDAPI bool WOWNERO_Wallet_rescanSpent(void* wallet_ptr); -// virtual void setOffline(bool offline) = 0; -extern ADDAPI void WOWNERO_Wallet_setOffline(void* wallet_ptr, bool offline); -// virtual bool isOffline() const = 0; -extern ADDAPI bool WOWNERO_Wallet_isOffline(void* wallet_ptr); -// virtual bool blackballOutputs(const std::vector &outputs, bool add) = 0; -// virtual bool blackballOutput(const std::string &amount, const std::string &offset) = 0; -// virtual bool unblackballOutput(const std::string &amount, const std::string &offset) = 0; -// virtual bool getRing(const std::string &key_image, std::vector &ring) const = 0; -// virtual bool getRings(const std::string &txid, std::vector>> &rings) const = 0; -// virtual bool setRing(const std::string &key_image, const std::vector &ring, bool relative) = 0; -// virtual void segregatePreForkOutputs(bool segregate) = 0; -extern ADDAPI void WOWNERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate); -// virtual void segregationHeight(uint64_t height) = 0; -extern ADDAPI void WOWNERO_Wallet_segregationHeight(void* wallet_ptr, uint64_t height); -// virtual void keyReuseMitigation2(bool mitigation) = 0; -extern ADDAPI void WOWNERO_Wallet_keyReuseMitigation2(void* wallet_ptr, bool mitigation); -// virtual bool lightWalletLogin(bool &isNewWallet) const = 0; -// virtual bool lightWalletImportWalletRequest(std::string &payment_id, uint64_t &fee, bool &new_request, bool &request_fulfilled, std::string &payment_address, std::string &status) = 0; -// virtual bool lockKeysFile() = 0; -extern ADDAPI bool WOWNERO_Wallet_lockKeysFile(void* wallet_ptr); -// virtual bool unlockKeysFile() = 0; -extern ADDAPI bool WOWNERO_Wallet_unlockKeysFile(void* wallet_ptr); -// virtual bool isKeysFileLocked() = 0; -extern ADDAPI bool WOWNERO_Wallet_isKeysFileLocked(void* wallet_ptr); -// virtual Device getDeviceType() const = 0; -extern ADDAPI int WOWNERO_Wallet_getDeviceType(void* wallet_ptr); -// virtual uint64_t coldKeyImageSync(uint64_t &spent, uint64_t &unspent) = 0; -extern ADDAPI uint64_t WOWNERO_Wallet_coldKeyImageSync(void* wallet_ptr, uint64_t spent, uint64_t unspent); -// virtual void deviceShowAddress(uint32_t accountIndex, uint32_t addressIndex, const std::string &paymentId) = 0; -extern ADDAPI const char* WOWNERO_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex); -// virtual bool reconnectDevice() = 0; -extern ADDAPI bool WOWNERO_Wallet_reconnectDevice(void* wallet_ptr); -// virtual uint64_t getBytesReceived() = 0; -extern ADDAPI uint64_t WOWNERO_Wallet_getBytesReceived(void* wallet_ptr); -// virtual uint64_t getBytesSent() = 0; -extern ADDAPI uint64_t WOWNERO_Wallet_getBytesSent(void* wallet_ptr); -// }; - -// struct WalletManager -// { -// virtual Wallet * createWallet(const std::string &path, const std::string &password, const std::string &language, NetworkType nettype, uint64_t kdf_rounds = 1) = 0; -extern ADDAPI void* WOWNERO_WalletManager_createWallet(void* wm_ptr, const char* path, const char* password, const char* language, int networkType); -// Wallet * createWallet(const std::string &path, const std::string &password, const std::string &language, bool testnet = false) // deprecated -// { -// return createWallet(path, password, language, testnet ? TESTNET : MAINNET); -// } -// virtual Wallet * openWallet(const std::string &path, const std::string &password, NetworkType nettype, uint64_t kdf_rounds = 1, WalletListener * listener = nullptr) = 0; -extern ADDAPI void* WOWNERO_WalletManager_openWallet(void* wm_ptr, const char* path, const char* password, int networkType); -// Wallet * openWallet(const std::string &path, const std::string &password, bool testnet = false) // deprecated -// { -// return openWallet(path, password, testnet ? TESTNET : MAINNET); -// } -// virtual Wallet * recoveryWallet(const std::string &path, const std::string &password, const std::string &mnemonic, -// NetworkType nettype = MAINNET, uint64_t restoreHeight = 0, uint64_t kdf_rounds = 1, -// const std::string &seed_offset = {}) = 0; -extern ADDAPI void* WOWNERO_WalletManager_recoveryWallet(void* wm_ptr, const char* path, const char* password, const char* mnemonic, int networkType, uint64_t restoreHeight, uint64_t kdfRounds, const char* seedOffset); -// Wallet * recoveryWallet(const std::string &path, const std::string &password, const std::string &mnemonic, -// bool testnet = false, uint64_t restoreHeight = 0) // deprecated -// { -// return recoveryWallet(path, password, mnemonic, testnet ? TESTNET : MAINNET, restoreHeight); -// } -// virtual Wallet * recoveryWallet(const std::string &path, const std::string &mnemonic, NetworkType nettype, uint64_t restoreHeight = 0) = 0; -// Wallet * recoveryWallet(const std::string &path, const std::string &mnemonic, bool testnet = false, uint64_t restoreHeight = 0) // deprecated -// { -// return recoveryWallet(path, mnemonic, testnet ? TESTNET : MAINNET, restoreHeight); -// } -// virtual Wallet * createWalletFromKeys(const std::string &path, -// const std::string &password, -// const std::string &language, -// NetworkType nettype, -// uint64_t restoreHeight, -// const std::string &addressString, -// const std::string &viewKeyString, -// const std::string &spendKeyString = "", -// uint64_t kdf_rounds = 1) = 0; -extern ADDAPI void* WOWNERO_WalletManager_createWalletFromKeys(void* wm_ptr, const char* path, const char* password, const char* language, int nettype, uint64_t restoreHeight, const char* addressString, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds); -// Wallet * createWalletFromKeys(const std::string &path, -// const std::string &password, -// const std::string &language, -// bool testnet, -// uint64_t restoreHeight, -// const std::string &addressString, -// const std::string &viewKeyString, -// const std::string &spendKeyString = "") // deprecated -// { -// return createWalletFromKeys(path, password, language, testnet ? TESTNET : MAINNET, restoreHeight, addressString, viewKeyString, spendKeyString); -// } -// virtual Wallet * createWalletFromKeys(const std::string &path, -// const std::string &language, -// NetworkType nettype, -// uint64_t restoreHeight, -// const std::string &addressString, -// const std::string &viewKeyString, -// const std::string &spendKeyString = "") = 0; -// Wallet * createWalletFromKeys(const std::string &path, -// const std::string &language, -// bool testnet, -// uint64_t restoreHeight, -// const std::string &addressString, -// const std::string &viewKeyString, -// const std::string &spendKeyString = "") // deprecated -// { -// return createWalletFromKeys(path, language, testnet ? TESTNET : MAINNET, restoreHeight, addressString, viewKeyString, spendKeyString); -// } -// virtual Wallet * createDeterministicWalletFromSpendKey(const std::string &path, -// const std::string &password, -// const std::string &language, -// NetworkType nettype, -// uint64_t restoreHeight, -// const std::string &spendKeyString, -// uint64_t kdf_rounds = 1) = 0; -extern ADDAPI void* WOWNERO_WalletManager_createDeterministicWalletFromSpendKey(void* wm_ptr, const char* path, const char* password, - const char* language, int nettype, uint64_t restoreHeight, - const char* spendKeyString, uint64_t kdf_rounds); -// virtual Wallet * createWalletFromDevice(const std::string &path, -// const std::string &password, -// NetworkType nettype, -// const std::string &deviceName, -// uint64_t restoreHeight = 0, -// const std::string &subaddressLookahead = "", -// uint64_t kdf_rounds = 1, -// WalletListener * listener = nullptr) = 0; -// virtual Wallet * createWalletFromPolyseed(const std::string &path, -// const std::string &password, -// NetworkType nettype, -// const std::string &mnemonic, -// const std::string &passphrase = "", -// bool newWallet = true, -// uint64_t restore_height = 0, -// uint64_t kdf_rounds = 1) = 0; -extern ADDAPI void* WOWNERO_WalletManager_createWalletFromPolyseed(void* wm_ptr, const char* path, const char* password, - int nettype, const char* mnemonic, const char* passphrase, - bool newWallet, uint64_t restore_height, uint64_t kdf_rounds); -// virtual bool closeWallet(Wallet *wallet, bool store = true) = 0; -extern ADDAPI bool WOWNERO_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store); -// virtual bool walletExists(const std::string &path) = 0; -extern ADDAPI bool WOWNERO_WalletManager_walletExists(void* wm_ptr, const char* path); -// virtual bool verifyWalletPassword(const std::string &keys_file_name, const std::string &password, bool no_spend_key, uint64_t kdf_rounds = 1) const = 0; -extern ADDAPI bool WOWNERO_WalletManager_verifyWalletPassword(void* wm_ptr, const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds); -// virtual bool queryWalletDevice(Wallet::Device& device_type, const std::string &keys_file_name, const std::string &password, uint64_t kdf_rounds = 1) const = 0; -// extern ADDAPI bool WOWNERO_WalletManager_queryWalletDevice(void* wm_ptr, int device_type, const char* keys_file_name, const char* password, uint64_t kdf_rounds); -// virtual std::vector findWallets(const std::string &path) = 0; -extern ADDAPI const char* WOWNERO_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator); -// virtual std::string errorString() const = 0; -extern ADDAPI const char* WOWNERO_WalletManager_errorString(void* wm_ptr); -// virtual void setDaemonAddress(const std::string &address) = 0; -extern ADDAPI void WOWNERO_WalletManager_setDaemonAddress(void* wm_ptr, const char* address); -// virtual bool connected(uint32_t *version = NULL) = 0; -// virtual uint64_t blockchainHeight() = 0; -extern ADDAPI uint64_t WOWNERO_WalletManager_blockchainHeight(void* wm_ptr); -// virtual uint64_t blockchainTargetHeight() = 0; -extern ADDAPI uint64_t WOWNERO_WalletManager_blockchainTargetHeight(void* wm_ptr); -// virtual uint64_t networkDifficulty() = 0; -extern ADDAPI uint64_t WOWNERO_WalletManager_networkDifficulty(void* wm_ptr); -// virtual double miningHashRate() = 0; -extern ADDAPI double WOWNERO_WalletManager_miningHashRate(void* wm_ptr); -// virtual uint64_t blockTarget() = 0; -extern ADDAPI uint64_t WOWNERO_WalletManager_blockTarget(void* wm_ptr); -// virtual bool isMining() = 0; -extern ADDAPI bool WOWNERO_WalletManager_isMining(void* wm_ptr); -// virtual bool startMining(const std::string &address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true) = 0; -extern ADDAPI bool WOWNERO_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery); -// virtual bool stopMining() = 0; -extern ADDAPI bool WOWNERO_WalletManager_stopMining(void* wm_ptr, const char* address); -// virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0; -extern ADDAPI const char* WOWNERO_WalletManager_resolveOpenAlias(void* wm_ptr, const char* address, bool dnssec_valid); -// static std::tuple checkUpdates( -// const std::string &software, -// std::string subdir, -// const char *buildtag = nullptr, -// const char *current_version = nullptr); -// virtual bool setProxy(const std::string &address) = 0; -extern ADDAPI bool WOWNERO_WalletManager_setProxy(void* wm_ptr, const char* address); -// }; - -int LogLevel_Silent = -1; -int LogLevel_0 = 0; -int LogLevel_1 = 1; -int LogLevel_2 = 2; -int LogLevel_3 = 3; -int LogLevel_4 = 4; -int LogLevel_Min = -1; -int LogLevel_Max = 4; - -// struct WalletManagerFactory -// { -// enum LogLevel { -// LogLevel_Silent = -1, -// LogLevel_0 = 0, -// LogLevel_1 = 1, -// LogLevel_2 = 2, -// LogLevel_3 = 3, -// LogLevel_4 = 4, -// LogLevel_Min = LogLevel_Silent, -// LogLevel_Max = LogLevel_4 -// }; -// static WalletManager * getWalletManager(); -extern ADDAPI void* WOWNERO_WalletManagerFactory_getWalletManager(); -// static void setLogLevel(int level); -extern ADDAPI void WOWNERO_WalletManagerFactory_setLogLevel(int level); -// static void setLogCategories(const std::string &categories); -extern ADDAPI void WOWNERO_WalletManagerFactory_setLogCategories(const char* categories); -// }; -// } - -extern ADDAPI void WOWNERO_DEBUG_test0(); -extern ADDAPI bool WOWNERO_DEBUG_test1(bool x); -extern ADDAPI int WOWNERO_DEBUG_test2(int x); -extern ADDAPI uint64_t WOWNERO_DEBUG_test3(uint64_t x); -extern ADDAPI void* WOWNERO_DEBUG_test4(uint64_t x); -extern ADDAPI const char* WOWNERO_DEBUG_test5(); -extern ADDAPI const char* WOWNERO_DEBUG_test5_std(); -extern ADDAPI bool WOWNERO_DEBUG_isPointerNull(void* wallet_ptr); - -// cake world - -extern ADDAPI void* WOWNERO_cw_getWalletListener(void* wallet_ptr); -extern ADDAPI void WOWNERO_cw_WalletListener_resetNeedToRefresh(void* cw_walletListener_ptr); -extern ADDAPI bool WOWNERO_cw_WalletListener_isNeedToRefresh(void* cw_walletListener_ptr); -extern ADDAPI bool WOWNERO_cw_WalletListener_isNewTransactionExist(void* cw_walletListener_ptr); -extern ADDAPI void WOWNERO_cw_WalletListener_resetIsNewTransactionExist(void* cw_walletListener_ptr); -extern ADDAPI uint64_t WOWNERO_cw_WalletListener_height(void* cw_walletListener_ptr); - -// legacy - -extern ADDAPI void* WOWNERO_deprecated_restore14WordSeed(char *path, char *password, char *seed, int32_t networkType); -extern ADDAPI void* WOWNERO_deprecated_create14WordSeed(char *path, char *password, char *language, int32_t networkType); -extern ADDAPI uint64_t WOWNERO_deprecated_14WordSeedHeight(char *seed); - -extern ADDAPI void WOWNERO_free(void* ptr); - -extern ADDAPI const char* WOWNERO_checksum_wallet2_api_c_h(); -extern ADDAPI const char* WOWNERO_checksum_wallet2_api_c_cpp(); -extern ADDAPI const char* WOWNERO_checksum_wallet2_api_c_exp(); - -#ifdef __cplusplus -} -#endif \ No newline at end of file diff --git a/wownero_libwallet2_api_c/src/main/cpp/wownero_checksum.c b/wownero_libwallet2_api_c/src/main/cpp/wownero_checksum.c new file mode 100644 index 0000000..b5ae1bc --- /dev/null +++ b/wownero_libwallet2_api_c/src/main/cpp/wownero_checksum.c @@ -0,0 +1,5 @@ +#include "wownero_checksum.h" + +const char * WOWNERO_wallet2_api_c_h_sha256 = "f99009d1ca1d1c783cc9aa0fb63f680d48753b88124fb5de2079c57b7e34c827"; +const char * WOWNERO_wallet2_api_c_cpp_sha256 = "a4539145783e7909afe087ce6ba5343b878e102bc493ab4283e653cd2b2c118e-cfd2a696245be112a01936d1f2f41b6eb7558376"; +const char * WOWNERO_wallet2_api_c_exp_sha256 = "5f53ea8bbe66a5e5aa6cbc4ca00695900e08589cfd32062e88965a24252d05ba"; diff --git a/wownero_libwallet2_api_c/src/main/cpp/wownero_wallet2_api_c.cpp b/wownero_libwallet2_api_c/src/main/cpp/wownero_wallet2_api_c.cpp new file mode 100644 index 0000000..7e15211 --- /dev/null +++ b/wownero_libwallet2_api_c/src/main/cpp/wownero_wallet2_api_c.cpp @@ -0,0 +1,2513 @@ +#include +#include "wownero_wallet2_api_c.h" +#include +#include "helpers.hpp" +#include +#include +#include "../../../../wownero/src/wallet/api/wallet2_api.h" +#include "../../../wownero-seed/include/wownero_seed/wownero_seed.hpp" +#include "wownero_checksum.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + + +// The code in here consists of simple wrappers, that convert +// more advanced c++ types (and function names) into simple C-compatible +// functions, so these implementations can be easly used from all languages +// that do support C interop (such as dart) +// +// +// Here is the most complex definition that we can find in the current codebase, it even includes +// a if statement - which in general I consider an anti-patter in just wrappers +// +// _____________ void* because C++ wallet->createTransaction returns a pointer to Monero::PendingTransaction, which we don't want to have exposed in C land +// / _____________ MONERO prefix just means that this function is using monero codebase, to not cause any symbols collision when using more than one libwallet2_api_c.so in a single program. +// | / _____________ Wallet is one of the classes in Monero namespace in the upstream codebase (see the include line above) +// | | / _____________ aaand it is calling createTransaction function. +// | | | / _________________________________________________________________________________ +// | | | | / \ All of these parameters can be found in the upstream +// | | | | | _____________/ function definition, if something was more complex - +// void* WOWNERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, / like std::set I've used splitString functions and introduced a new +// uint64_t amount, uint32_t mixin_count, / parameter - separator, as it is the simplest way to get vector onto +// int pendingTransactionPriority, / C side from more advanced world. +// uint32_t subaddr_account, / +// const char* preferredInputs, const char* separator) { +// Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); <------------ We are converting the void* into Monero::Wallet* +// Monero::optional optAmount; <------------- optional by default +// if (amount != 0) {------------------\ We set this optional parameter only when it isn't zero +// optAmount = amount; | +// }___________________________________/ +// std::set subaddr_indices = {}; ------------- Default value +// std::set preferred_inputs = splitString(std::string(preferredInputs), std::string(separator)); <------------- We are using helpers.cpp function to split a string into std::set +// return wallet->createTransaction(std::string(dst_addr), std::string(payment_id),-\ const char * is getting casted onto std::string +// optAmount, mixin_count, \_____________/ +// PendingTransaction_Priority_fromInt(pendingTransactionPriority), <------------- special case for this function to get native type instead of int value. +// subaddr_account, subaddr_indices, preferred_inputs); +// } +// +// +// One case which is not covered here is when we have to return a string +// const char* WOWNERO_PendingTransaction_errorString(void* pendingTx_ptr) { +// Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); +// std::string str = pendingTx->errorString(); <------------- get the actual string from the upstream codebase +// const std::string::size_type size = str.size(); ------------------------------\ +// char *buffer = new char[size + 1]; //we need extra char for NUL | Copy the string onto a new memory so it won't get freed after the function returns +// memcpy(buffer, str.c_str(), size + 1); | NOTE: This requires us to call free() after we are done with the text processing +// return buffer; ______________________________________________________________/ +// } +// +// + +// PendingTransaction + +int WOWNERO_PendingTransaction_status(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->status(); + DEBUG_END() +} +const char* WOWNERO_PendingTransaction_errorString(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::string str = pendingTx->errorString(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +bool WOWNERO_PendingTransaction_commit(void* pendingTx_ptr, const char* filename, bool overwrite) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->commit(std::string(filename), overwrite); + DEBUG_END() +} +uint64_t WOWNERO_PendingTransaction_amount(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->amount(); + DEBUG_END() +} +uint64_t WOWNERO_PendingTransaction_dust(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->dust(); + DEBUG_END() +} +uint64_t WOWNERO_PendingTransaction_fee(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->fee(); + DEBUG_END() +} +const char* WOWNERO_PendingTransaction_txid(void* pendingTx_ptr, const char* separator) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::vector txid = pendingTx->txid(); + return vectorToString(txid, std::string(separator)); + DEBUG_END() +} +uint64_t WOWNERO_PendingTransaction_txCount(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->txCount(); + DEBUG_END() +} +const char* WOWNERO_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::vector subaddrAccount = pendingTx->subaddrAccount(); + return vectorToString(subaddrAccount, std::string(separator)); + DEBUG_END() +} +const char* WOWNERO_PendingTransaction_subaddrIndices(void* pendingTx_ptr, const char* separator) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::vector> subaddrIndices = pendingTx->subaddrIndices(); + return vectorToString(subaddrIndices, std::string(separator)); + DEBUG_END() +} +const char* WOWNERO_PendingTransaction_multisigSignData(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::string str = pendingTx->multisigSignData(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +void WOWNERO_PendingTransaction_signMultisigTx(void* pendingTx_ptr) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + return pendingTx->signMultisigTx(); + DEBUG_END() +} +const char* WOWNERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::vector txid = pendingTx->signersKeys(); + return vectorToString(txid, std::string(separator)); + DEBUG_END() +} + +const char* WOWNERO_PendingTransaction_hex(void* pendingTx_ptr, const char* separator) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::vector txid = pendingTx->hex(); + return vectorToString(txid, std::string(separator)); + DEBUG_END() +} + +// const char* WOWNERO_PendingTransaction_txHex(void* pendingTx_ptr, const char* separator) { +// Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); +// std::vector txid = pendingTx->txHex(); +// return vectorToString(txid, std::string(separator)); +// } + +const char* WOWNERO_PendingTransaction_txKey(void* pendingTx_ptr, const char* separator) { + DEBUG_START() + Monero::PendingTransaction *pendingTx = reinterpret_cast(pendingTx_ptr); + std::vector txid = pendingTx->txKey(); + return vectorToString(txid, std::string(separator)); + DEBUG_END() +} + +// UnsignedTransaction + +int WOWNERO_UnsignedTransaction_status(void* unsignedTx_ptr) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return unsignedTx->status(); + DEBUG_END() +} +const char* WOWNERO_UnsignedTransaction_errorString(void* unsignedTx_ptr) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + std::string str = unsignedTx->errorString(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +const char* WOWNERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return vectorToString(unsignedTx->amount(), std::string(separator)); + DEBUG_END() +} +const char* WOWNERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return vectorToString(unsignedTx->fee(), std::string(separator)); + DEBUG_END() +} +const char* WOWNERO_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return vectorToString(unsignedTx->mixin(), std::string(separator)); + DEBUG_END() +} +const char* WOWNERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + std::string str = unsignedTx->confirmationMessage(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +const char* WOWNERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return vectorToString(unsignedTx->paymentId(), std::string(separator)); + DEBUG_END() +} +const char* WOWNERO_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return vectorToString(unsignedTx->recipientAddress(), std::string(separator)); + DEBUG_END() +} +uint64_t WOWNERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return unsignedTx->minMixinCount(); + DEBUG_END() +} +uint64_t WOWNERO_UnsignedTransaction_txCount(void* unsignedTx_ptr) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return unsignedTx->txCount(); + DEBUG_END() +} +bool WOWNERO_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName) { + DEBUG_START() + Monero::UnsignedTransaction *unsignedTx = reinterpret_cast(unsignedTx_ptr); + return unsignedTx->sign(std::string(signedFileName)); + DEBUG_END() +} + +// TransactionInfo +int WOWNERO_TransactionInfo_direction(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->direction(); + DEBUG_END() +} +bool WOWNERO_TransactionInfo_isPending(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->isPending(); + DEBUG_END() +} +bool WOWNERO_TransactionInfo_isFailed(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->isFailed(); + DEBUG_END() +} +bool WOWNERO_TransactionInfo_isCoinbase(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->isCoinbase(); + DEBUG_END() +} +uint64_t WOWNERO_TransactionInfo_amount(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->amount(); + DEBUG_END() +} +uint64_t WOWNERO_TransactionInfo_fee(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->fee(); + DEBUG_END() +} +uint64_t WOWNERO_TransactionInfo_blockHeight(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->blockHeight(); + DEBUG_END() +} +const char* WOWNERO_TransactionInfo_description(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + std::string str = txInfo->description(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +const char* WOWNERO_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + std::set subaddrIndex = txInfo->subaddrIndex(); + return vectorToString(subaddrIndex, std::string(separator)); + DEBUG_END() +} +uint32_t WOWNERO_TransactionInfo_subaddrAccount(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->subaddrAccount(); + DEBUG_END() +} +const char* WOWNERO_TransactionInfo_label(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + std::string str = txInfo->label(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +uint64_t WOWNERO_TransactionInfo_confirmations(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->confirmations(); + DEBUG_END() +} +uint64_t WOWNERO_TransactionInfo_unlockTime(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->unlockTime(); + DEBUG_END() +} +const char* WOWNERO_TransactionInfo_hash(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + std::string str = txInfo->hash(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +uint64_t WOWNERO_TransactionInfo_timestamp(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->timestamp(); + DEBUG_END() +} +const char* WOWNERO_TransactionInfo_paymentId(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + std::string str = txInfo->paymentId(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +int WOWNERO_TransactionInfo_transfers_count(void* txInfo_ptr) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->transfers().size(); + DEBUG_END() +} + +uint64_t WOWNERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + return txInfo->transfers()[index].amount; + DEBUG_END() +} + +const char* WOWNERO_TransactionInfo_transfers_address(void* txInfo_ptr, int index) { + DEBUG_START() + Monero::TransactionInfo *txInfo = reinterpret_cast(txInfo_ptr); + std::string str = txInfo->transfers()[index].address; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + + + + +// TransactionHistory +int WOWNERO_TransactionHistory_count(void* txHistory_ptr) { + DEBUG_START() + Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); + return txHistory->count(); + DEBUG_END() +} +void* WOWNERO_TransactionHistory_transaction(void* txHistory_ptr, int index) { + DEBUG_START() + Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); + return reinterpret_cast(txHistory->transaction(index)); + DEBUG_END() +} +void* WOWNERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id) { + DEBUG_START() + Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); + return reinterpret_cast(txHistory->transaction(std::string(id))); + DEBUG_END() +} + +void WOWNERO_TransactionHistory_refresh(void* txHistory_ptr) { + DEBUG_START() + Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); + return txHistory->refresh(); + DEBUG_END() +} +void WOWNERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note) { + DEBUG_START() + Monero::TransactionHistory *txHistory = reinterpret_cast(txHistory_ptr); + return txHistory->setTxNote(std::string(txid), std::string(note)); + DEBUG_END() +} + +// AddressBokRow + +// std::string extra; +const char* WOWNERO_AddressBookRow_extra(void* addressBookRow_ptr) { + DEBUG_START() + Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); + std::string str = addressBookRow->extra; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getAddress() const {return m_address;} +const char* WOWNERO_AddressBookRow_getAddress(void* addressBookRow_ptr) { + DEBUG_START() + Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); + std::string str = addressBookRow->getAddress(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getDescription() const {return m_description;} +const char* WOWNERO_AddressBookRow_getDescription(void* addressBookRow_ptr) { + DEBUG_START() + Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); + std::string str = addressBookRow->getDescription(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getPaymentId() const {return m_paymentId;} +const char* WOWNERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr) { + DEBUG_START() + Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); + std::string str = addressBookRow->getPaymentId(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::size_t getRowId() const {return m_rowId;} +size_t WOWNERO_AddressBookRow_getRowId(void* addressBookRow_ptr) { + DEBUG_START() + Monero::AddressBookRow *addressBookRow = reinterpret_cast(addressBookRow_ptr); + return addressBookRow->getRowId(); + DEBUG_END() +} + +// AddressBook +// virtual std::vector getAll() const = 0; +int WOWNERO_AddressBook_getAll_size(void* addressBook_ptr) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->getAll().size(); + DEBUG_END() +} +void* WOWNERO_AddressBook_getAll_byIndex(void* addressBook_ptr, int index) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->getAll()[index]; + DEBUG_END() +} +// virtual bool addRow(const std::string &dst_addr , const std::string &payment_id, const std::string &description) = 0; +bool WOWNERO_AddressBook_addRow(void* addressBook_ptr, const char* dst_addr , const char* payment_id, const char* description) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->addRow(std::string(dst_addr), std::string(payment_id), std::string(description)); + DEBUG_END() +} +// virtual bool deleteRow(std::size_t rowId) = 0; +bool WOWNERO_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->deleteRow(rowId); + DEBUG_END() +} +// virtual bool setDescription(std::size_t index, const std::string &description) = 0; +bool WOWNERO_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->setDescription(rowId, std::string(description)); + DEBUG_END() +} +// virtual void refresh() = 0; +void WOWNERO_AddressBook_refresh(void* addressBook_ptr) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->refresh(); + DEBUG_END() +} +// virtual std::string errorString() const = 0; +const char* WOWNERO_AddressBook_errorString(void* addressBook_ptr) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + std::string str = addressBook->errorString(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual int errorCode() const = 0; +int WOWNERO_AddressBook_errorCode(void* addressBook_ptr) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->errorCode(); + DEBUG_END() +} +// virtual int lookupPaymentID(const std::string &payment_id) const = 0; +int WOWNERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id) { + DEBUG_START() + Monero::AddressBook *addressBook = reinterpret_cast(addressBook_ptr); + return addressBook->lookupPaymentID(std::string(payment_id)); + DEBUG_END() +} + +// CoinsInfo +uint64_t WOWNERO_CoinsInfo_blockHeight(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->blockHeight(); + DEBUG_END() +} +// virtual std::string hash() const = 0; +const char* WOWNERO_CoinsInfo_hash(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + std::string str = coinsInfo->hash(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual size_t internalOutputIndex() const = 0; +size_t WOWNERO_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->internalOutputIndex(); + DEBUG_END() +} +// virtual uint64_t globalOutputIndex() const = 0; +uint64_t WOWNERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->globalOutputIndex(); + DEBUG_END() +} +// virtual bool spent() const = 0; +bool WOWNERO_CoinsInfo_spent(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->spent(); + DEBUG_END() +} +// virtual bool frozen() const = 0; +bool WOWNERO_CoinsInfo_frozen(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->frozen(); + DEBUG_END() +} +// virtual uint64_t spentHeight() const = 0; +uint64_t WOWNERO_CoinsInfo_spentHeight(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->spentHeight(); + DEBUG_END() +} +// virtual uint64_t amount() const = 0; +uint64_t WOWNERO_CoinsInfo_amount(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->amount(); + DEBUG_END() +} +// virtual bool rct() const = 0; +bool WOWNERO_CoinsInfo_rct(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->rct(); + DEBUG_END() +} +// virtual bool keyImageKnown() const = 0; +bool WOWNERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->keyImageKnown(); + DEBUG_END() +} +// virtual size_t pkIndex() const = 0; +size_t WOWNERO_CoinsInfo_pkIndex(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->pkIndex(); + DEBUG_END() +} +// virtual uint32_t subaddrIndex() const = 0; +uint32_t WOWNERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->subaddrIndex(); + DEBUG_END() +} +// virtual uint32_t subaddrAccount() const = 0; +uint32_t WOWNERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->subaddrAccount(); + DEBUG_END() +} +// virtual std::string address() const = 0; +const char* WOWNERO_CoinsInfo_address(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + std::string str = coinsInfo->address(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual std::string addressLabel() const = 0; +const char* WOWNERO_CoinsInfo_addressLabel(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + std::string str = coinsInfo->addressLabel(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual std::string keyImage() const = 0; +const char* WOWNERO_CoinsInfo_keyImage(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + std::string str = coinsInfo->keyImage(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual uint64_t unlockTime() const = 0; +uint64_t WOWNERO_CoinsInfo_unlockTime(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->unlockTime(); + DEBUG_END() +} +// virtual bool unlocked() const = 0; +bool WOWNERO_CoinsInfo_unlocked(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->unlocked(); + DEBUG_END() +} +// virtual std::string pubKey() const = 0; +const char* WOWNERO_CoinsInfo_pubKey(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + std::string str = coinsInfo->pubKey(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual bool coinbase() const = 0; +bool WOWNERO_CoinsInfo_coinbase(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + return coinsInfo->coinbase(); + DEBUG_END() +} +// virtual std::string description() const = 0; +const char* WOWNERO_CoinsInfo_description(void* coinsInfo_ptr) { + DEBUG_START() + Monero::CoinsInfo *coinsInfo = reinterpret_cast(coinsInfo_ptr); + std::string str = coinsInfo->description(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + + +// coins + +// virtual ~Coins() = 0; +// virtual int count() const = 0; +int WOWNERO_Coins_count(void* coins_ptr) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->count(); + DEBUG_END() +} +// virtual CoinsInfo * coin(int index) const = 0; +void* WOWNERO_Coins_coin(void* coins_ptr, int index) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->coin(index); + DEBUG_END() +} + +int WOWNERO_Coins_getAll_size(void* coins_ptr) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->getAll().size(); + DEBUG_END() +} +void* WOWNERO_Coins_getAll_byIndex(void* coins_ptr, int index) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->getAll()[index]; + DEBUG_END() +} + +// virtual std::vector getAll() const = 0; +// virtual void refresh() = 0; +void WOWNERO_Coins_refresh(void* coins_ptr) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->refresh(); + DEBUG_END() +} +// virtual void setFrozen(std::string public_key) = 0; +void WOWNERO_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->setFrozen(std::string(public_key)); + DEBUG_END() +} +// virtual void setFrozen(int index) = 0; +void WOWNERO_Coins_setFrozen(void* coins_ptr, int index) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->setFrozen(index); + DEBUG_END() +} +// virtual void thaw(int index) = 0; +void WOWNERO_Coins_thaw(void* coins_ptr, int index) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->thaw(index); + DEBUG_END() +} +// virtual void thaw(std::string public_key) = 0; +void WOWNERO_Coins_thawByPublicKey(void* coins_ptr, const char* public_key) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->thaw(std::string(public_key)); + DEBUG_END() +} +// virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0; +bool WOWNERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + return coins->isTransferUnlocked(unlockTime, blockHeight); + DEBUG_END() +} +// virtual void setDescription(const std::string &public_key, const std::string &description) = 0; +void WOWNERO_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description) { + DEBUG_START() + Monero::Coins *coins = reinterpret_cast(coins_ptr); + coins->setDescription(std::string(public_key), std::string(description)); + DEBUG_END() +} + +// SubaddressRow + +// std::string extra; +const char* WOWNERO_SubaddressRow_extra(void* subaddressRow_ptr) { + DEBUG_START() + Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); + std::string str = subaddressRow->extra; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getAddress() const {return m_address;} +const char* WOWNERO_SubaddressRow_getAddress(void* subaddressRow_ptr) { + DEBUG_START() + Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); + std::string str = subaddressRow->getAddress(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getLabel() const {return m_label;} +const char* WOWNERO_SubaddressRow_getLabel(void* subaddressRow_ptr) { + DEBUG_START() + Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); + std::string str = subaddressRow->getLabel(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::size_t getRowId() const {return m_rowId;} +size_t WOWNERO_SubaddressRow_getRowId(void* subaddressRow_ptr) { + DEBUG_START() + Monero::SubaddressRow *subaddressRow = reinterpret_cast(subaddressRow_ptr); + return subaddressRow->getRowId(); + DEBUG_END() +} + +// Subaddress + +int WOWNERO_Subaddress_getAll_size(void* subaddress_ptr) { + DEBUG_START() + Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); + return subaddress->getAll().size(); + DEBUG_END() +} +void* WOWNERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index) { + DEBUG_START() + Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); + return subaddress->getAll()[index]; + DEBUG_END() +} +// virtual void addRow(uint32_t accountIndex, const std::string &label) = 0; +void WOWNERO_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label) { + DEBUG_START() + Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); + return subaddress->addRow(accountIndex, std::string(label)); + DEBUG_END() +} +// virtual void setLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0; +void WOWNERO_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label) { + DEBUG_START() + Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); + return subaddress->setLabel(accountIndex, addressIndex, std::string(label)); + DEBUG_END() +} +// virtual void refresh(uint32_t accountIndex) = 0; +void WOWNERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex) { + DEBUG_START() + Monero::Subaddress *subaddress = reinterpret_cast(subaddress_ptr); + return subaddress->refresh(accountIndex); + DEBUG_END() +} + +// SubaddressAccountRow + +// std::string extra; +const char* WOWNERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr) { + DEBUG_START() + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); + std::string str = subaddressAccountRow->extra; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getAddress() const {return m_address;} +const char* WOWNERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr) { + DEBUG_START() + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); + std::string str = subaddressAccountRow->getAddress(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getLabel() const {return m_label;} +const char* WOWNERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr) { + DEBUG_START() + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); + std::string str = subaddressAccountRow->getLabel(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getBalance() const {return m_balance;} +const char* WOWNERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr) { + DEBUG_START() + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); + std::string str = subaddressAccountRow->getBalance(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string getUnlockedBalance() const {return m_unlockedBalance;} +const char* WOWNERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr) { + DEBUG_START() + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); + std::string str = subaddressAccountRow->getUnlockedBalance(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::size_t getRowId() const {return m_rowId;} +size_t WOWNERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr) { + DEBUG_START() + Monero::SubaddressAccountRow *subaddressAccountRow = reinterpret_cast(subaddressAccountRow_ptr); + return subaddressAccountRow->getRowId(); + DEBUG_END() +} + +// struct SubaddressAccount +// { +// virtual ~SubaddressAccount() = 0; +// virtual std::vector getAll() const = 0; +int WOWNERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr) { + DEBUG_START() + Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); + return subaddress->getAll().size(); + DEBUG_END() +} +void* WOWNERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index) { + DEBUG_START() + Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); + return subaddress->getAll()[index]; + DEBUG_END() +} +// virtual void addRow(const std::string &label) = 0; +void WOWNERO_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label) { + DEBUG_START() + Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); + return subaddress->addRow(std::string(label)); + DEBUG_END() +} +// virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0; +void WOWNERO_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label) { + DEBUG_START() + Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); + return subaddress->setLabel(accountIndex, std::string(label)); + DEBUG_END() +} +// virtual void refresh() = 0; +void WOWNERO_SubaddressAccount_refresh(void* subaddressAccount_ptr) { + DEBUG_START() + Monero::SubaddressAccount *subaddress = reinterpret_cast(subaddressAccount_ptr); + return subaddress->refresh(); + DEBUG_END() +} + +// MultisigState + +// bool isMultisig; +bool WOWNERO_MultisigState_isMultisig(void* multisigState_ptr) { + DEBUG_START() + Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); + return multisigState->isMultisig; + DEBUG_END() +} +// bool isReady; +bool WOWNERO_MultisigState_isReady(void* multisigState_ptr) { + DEBUG_START() + Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); + return multisigState->isReady; + DEBUG_END() +} +// uint32_t threshold; +uint32_t WOWNERO_MultisigState_threshold(void* multisigState_ptr) { + DEBUG_START() + Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); + return multisigState->threshold; + DEBUG_END() +} +// uint32_t total; +uint32_t WOWNERO_MultisigState_total(void* multisigState_ptr) { + DEBUG_START() + Monero::MultisigState *multisigState = reinterpret_cast(multisigState_ptr); + return multisigState->total; + DEBUG_END() +} + +// DeviceProgress + + +// virtual double progress() const { return m_progress; } +bool WOWNERO_DeviceProgress_progress(void* deviceProgress_ptr) { + DEBUG_START() + Monero::DeviceProgress *deviceProgress = reinterpret_cast(deviceProgress_ptr); + return deviceProgress->progress(); + DEBUG_END() +} +// virtual bool indeterminate() const { return m_indeterminate; } +bool WOWNERO_DeviceProgress_indeterminate(void* deviceProgress_ptr) { + DEBUG_START() + Monero::DeviceProgress *deviceProgress = reinterpret_cast(deviceProgress_ptr); + return deviceProgress->indeterminate(); + DEBUG_END() +} + +// Wallet + +const char* WOWNERO_Wallet_seed(void* wallet_ptr, const char* seed_offset) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->seed(std::string(seed_offset)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* WOWNERO_Wallet_getSeedLanguage(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->getSeedLanguage(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +void WOWNERO_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setSeedLanguage(std::string(arg)); + DEBUG_END() +} + +int WOWNERO_Wallet_status(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->status(); + DEBUG_END() +} + +const char* WOWNERO_Wallet_errorString(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->errorString(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + + +bool WOWNERO_Wallet_setPassword(void* wallet_ptr, const char* password) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setPassword(std::string(password)); + DEBUG_END() +} + +const char* WOWNERO_Wallet_getPassword(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->getPassword(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +bool WOWNERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setDevicePin(std::string(pin)); + DEBUG_END() +} + +bool WOWNERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setDevicePassphrase(std::string(passphrase)); + DEBUG_END() +} + +const char* WOWNERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->address(accountIndex, addressIndex); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* WOWNERO_Wallet_path(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->path(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +int WOWNERO_Wallet_nettype(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->nettype(); + DEBUG_END() +} +uint8_t WOWNERO_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->useForkRules(version, early_blocks); + DEBUG_END() +} +const char* WOWNERO_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->integratedAddress(std::string(payment_id)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* WOWNERO_Wallet_secretViewKey(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->secretViewKey(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* WOWNERO_Wallet_publicViewKey(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->publicViewKey(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* WOWNERO_Wallet_secretSpendKey(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->secretSpendKey(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* WOWNERO_Wallet_publicSpendKey(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->publicSpendKey(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +const char* WOWNERO_Wallet_publicMultisigSignerKey(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->publicMultisigSignerKey(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +void WOWNERO_Wallet_stop(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + wallet->stop(); + DEBUG_END() +} + +bool WOWNERO_Wallet_store(void* wallet_ptr, const char* path) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->store(std::string(path)); + DEBUG_END() +} +const char* WOWNERO_Wallet_filename(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->filename(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +const char* WOWNERO_Wallet_keysFilename(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->keysFilename(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +// virtual bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit = 0, const std::string &daemon_username = "", const std::string &daemon_password = "", bool use_ssl = false, bool lightWallet = false, const std::string &proxy_address = "") = 0; +bool WOWNERO_Wallet_init(void* wallet_ptr, const char* daemon_address, uint64_t upper_transaction_size_limit, const char* daemon_username, const char* daemon_password, bool use_ssl, bool lightWallet, const char* proxy_address) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->init(std::string(daemon_address), upper_transaction_size_limit, std::string(daemon_username), std::string(daemon_password), use_ssl, lightWallet, std::string(proxy_address)); + DEBUG_END() +} +bool WOWNERO_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->createWatchOnly(std::string(path), std::string(password), std::string(language)); + DEBUG_END() +} + +void WOWNERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setRefreshFromBlockHeight(refresh_from_block_height); + DEBUG_END() +} + +uint64_t WOWNERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->getRefreshFromBlockHeight(); + DEBUG_END() +} + +void WOWNERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setRecoveringFromSeed(recoveringFromSeed); + DEBUG_END() +} +void WOWNERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setRecoveringFromDevice(recoveringFromDevice); + DEBUG_END() +} +void WOWNERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setSubaddressLookahead(major, minor); + DEBUG_END() +} + +bool WOWNERO_Wallet_connectToDaemon(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->connectToDaemon(); + DEBUG_END() +} +int WOWNERO_Wallet_connected(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->connected(); + DEBUG_END() +} +void WOWNERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setTrustedDaemon(arg); + DEBUG_END() +} +bool WOWNERO_Wallet_trustedDaemon(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->trustedDaemon(); + DEBUG_END() +} +bool WOWNERO_Wallet_setProxy(void* wallet_ptr, const char* address) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setProxy(std::string(address)); + DEBUG_END() +} + +uint64_t WOWNERO_Wallet_balance(void* wallet_ptr, uint32_t accountIndex) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->balance(accountIndex); + DEBUG_END() +} + +uint64_t WOWNERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->unlockedBalance(accountIndex); + DEBUG_END() +} + +uint64_t WOWNERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->viewOnlyBalance(accountIndex); + DEBUG_END() +} + +// TODO +bool WOWNERO_Wallet_watchOnly(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->watchOnly(); + DEBUG_END() +} +bool WOWNERO_Wallet_isDeterministic(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->isDeterministic(); + DEBUG_END() +} +uint64_t WOWNERO_Wallet_blockChainHeight(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->blockChainHeight(); + DEBUG_END() +} +uint64_t WOWNERO_Wallet_approximateBlockChainHeight(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->approximateBlockChainHeight(); + DEBUG_END() +} +uint64_t WOWNERO_Wallet_estimateBlockChainHeight(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->estimateBlockChainHeight(); + DEBUG_END() +} +uint64_t WOWNERO_Wallet_daemonBlockChainHeight(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->daemonBlockChainHeight(); + DEBUG_END() +} + +uint64_t WOWNERO_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->daemonBlockChainTargetHeight(); + DEBUG_END() +} +bool WOWNERO_Wallet_synchronized(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->synchronized(); + DEBUG_END() +} + +const char* WOWNERO_Wallet_displayAmount(uint64_t amount) { + DEBUG_START() + std::string str = Monero::Wallet::displayAmount(amount); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +// static uint64_t amountFromString(const std::string &amount); +uint64_t WOWNERO_Wallet_amountFromString(const char* amount) { + DEBUG_START() + return Monero::Wallet::amountFromString(amount); + DEBUG_END() +} +// static uint64_t amountFromDouble(double amount); +uint64_t WOWNERO_Wallet_amountFromDouble(double amount) { + DEBUG_START() + return Monero::Wallet::amountFromDouble(amount); + DEBUG_END() +} +// static std::string genPaymentId(); +const char* WOWNERO_Wallet_genPaymentId() { + DEBUG_START() + std::string str = Monero::Wallet::genPaymentId(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// static bool paymentIdValid(const std::string &paiment_id); +bool WOWNERO_Wallet_paymentIdValid(const char* paiment_id) { + DEBUG_START() + return Monero::Wallet::paymentIdValid(std::string(paiment_id)); + DEBUG_END() +} +bool WOWNERO_Wallet_addressValid(const char* str, int nettype) { + DEBUG_START() + // Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return Monero::Wallet::addressValid(std::string(str), nettype); + DEBUG_END() +} + +bool WOWNERO_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype) { + DEBUG_START() + std::string error; + return Monero::Wallet::keyValid(std::string(secret_key_string), std::string(address_string), isViewKey, nettype, error); + DEBUG_END() +} +const char* WOWNERO_Wallet_keyValid_error(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype) { + DEBUG_START() + std::string str; + Monero::Wallet::keyValid(std::string(secret_key_string), std::string(address_string), isViewKey, nettype, str); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +const char* WOWNERO_Wallet_paymentIdFromAddress(const char* strarg, int nettype) { + DEBUG_START() + std::string str = Monero::Wallet::paymentIdFromAddress(std::string(strarg), nettype); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +uint64_t WOWNERO_Wallet_maximumAllowedAmount() { + DEBUG_START() + return Monero::Wallet::maximumAllowedAmount(); + DEBUG_END() +} + +void WOWNERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->init(argv0, default_log_base_name, log_path, console); + DEBUG_END() +} +const char* WOWNERO_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string seed = ""; + std::string _passphrase = std::string(passphrase); + wallet->getPolyseed(seed, _passphrase); + std::string str = seed; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// static bool createPolyseed(std::string &seed_words, std::string &err, const std::string &language = "English"); +const char* WOWNERO_Wallet_createPolyseed(const char* language) { + DEBUG_START() + std::string seed_words = ""; + std::string err; + Monero::Wallet::createPolyseed(seed_words, err, std::string(language)); + std::string str = seed_words; + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +void WOWNERO_Wallet_startRefresh(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->startRefresh(); + DEBUG_END() +} +void WOWNERO_Wallet_pauseRefresh(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->pauseRefresh(); + DEBUG_END() +} +bool WOWNERO_Wallet_refresh(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->refresh(); + DEBUG_END() +} +void WOWNERO_Wallet_refreshAsync(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->refreshAsync(); + DEBUG_END() +} +bool WOWNERO_Wallet_rescanBlockchain(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->rescanBlockchain(); + DEBUG_END() +} +void WOWNERO_Wallet_rescanBlockchainAsync(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->rescanBlockchainAsync(); + DEBUG_END() +} +void WOWNERO_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setAutoRefreshInterval(millis); + DEBUG_END() +} +int WOWNERO_Wallet_autoRefreshInterval(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->autoRefreshInterval(); + DEBUG_END() +} +void WOWNERO_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->addSubaddressAccount(std::string(label)); + DEBUG_END() +} +size_t WOWNERO_Wallet_numSubaddressAccounts(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->numSubaddressAccounts(); + DEBUG_END() +} +size_t WOWNERO_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->numSubaddresses(accountIndex); + DEBUG_END() +} +void WOWNERO_Wallet_addSubaddress(void* wallet_ptr, uint32_t accountIndex, const char* label) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->addSubaddress(accountIndex, std::string(label)); + DEBUG_END() +} +const char* WOWNERO_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->getSubaddressLabel(accountIndex, addressIndex); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +void WOWNERO_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setSubaddressLabel(accountIndex, addressIndex, std::string(label)); + DEBUG_END() +} +const char* WOWNERO_Wallet_getMultisigInfo(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->getMultisigInfo(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +Monero::PendingTransaction::Priority PendingTransaction_Priority_fromInt(int value) { + switch(value) { + case 0: return Monero::PendingTransaction::Priority::Priority_Default; + case 1: return Monero::PendingTransaction::Priority::Priority_Low; + case 2: return Monero::PendingTransaction::Priority::Priority_Medium; + case 3: return Monero::PendingTransaction::Priority::Priority_High; + default: return Monero::PendingTransaction::Priority::Priority_Default; + } +} + +void* WOWNERO_Wallet_createTransactionMultDest(void* wallet_ptr, const char* dst_addr_list, const char* dst_addr_list_separator, const char* payment_id, + bool amount_sweep_all, const char* amount_list, const char* amount_list_separator, uint32_t mixin_count, + int pendingTransactionPriority, + uint32_t subaddr_account, + const char* preferredInputs, const char* preferredInputs_separator) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::vector dst_addr = splitStringVector(std::string(dst_addr_list), std::string(dst_addr_list_separator)); + + Monero::optional> optAmount; + if (!amount_sweep_all) { + optAmount = splitStringUint(std::string(amount_list), std::string(amount_list_separator));; + } + std::set subaddr_indices = {}; + std::set preferred_inputs = splitString(std::string(preferredInputs), std::string(preferredInputs_separator)); + + return wallet->createTransactionMultDest( + dst_addr, std::string(payment_id), + optAmount, mixin_count, + PendingTransaction_Priority_fromInt(pendingTransactionPriority), + subaddr_account, + subaddr_indices, + preferred_inputs + ); + DEBUG_END() +} + +void* WOWNERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, + uint64_t amount, uint32_t mixin_count, + int pendingTransactionPriority, + uint32_t subaddr_account, + const char* preferredInputs, const char* separator) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + Monero::optional optAmount; + if (amount != 0) { + optAmount = amount; + } + std::set subaddr_indices = {}; + std::set preferred_inputs = splitString(std::string(preferredInputs), std::string(separator)); + return wallet->createTransaction(std::string(dst_addr), std::string(payment_id), + optAmount, mixin_count, + PendingTransaction_Priority_fromInt(pendingTransactionPriority), + subaddr_account, subaddr_indices, preferred_inputs); + DEBUG_END() +} + +void* WOWNERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* fileName) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->loadUnsignedTx(std::string(fileName)); + DEBUG_END() +} +bool WOWNERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->submitTransaction(std::string(fileName)); + DEBUG_END() +} +bool WOWNERO_Wallet_hasUnknownKeyImages(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->hasUnknownKeyImages(); + DEBUG_END() +} +bool WOWNERO_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->exportKeyImages(std::string(filename), all); + DEBUG_END() +} +bool WOWNERO_Wallet_importKeyImages(void* wallet_ptr, const char* filename) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->importKeyImages(std::string(filename)); + DEBUG_END() +} +bool WOWNERO_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool all) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->exportOutputs(std::string(filename), all); + DEBUG_END() +} +bool WOWNERO_Wallet_importOutputs(void* wallet_ptr, const char* filename) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->importOutputs(std::string(filename)); + DEBUG_END() +} +// virtual bool setupBackgroundSync(const BackgroundSyncType background_sync_type, const std::string &wallet_password, const optional &background_cache_password) = 0; +bool WOWNERO_Wallet_setupBackgroundSync(void* wallet_ptr, int background_sync_type, const char* wallet_password, const char* background_cache_password) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setupBackgroundSync(Monero::Wallet::BackgroundSyncType::BackgroundSync_CustomPassword, std::string(wallet_password), std::string(background_cache_password)); + DEBUG_END() +} +// virtual BackgroundSyncType getBackgroundSyncType() const = 0; +int WOWNERO_Wallet_getBackgroundSyncType(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->getBackgroundSyncType(); + DEBUG_END() +} +// virtual bool startBackgroundSync() = 0; +bool WOWNERO_Wallet_startBackgroundSync(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->startBackgroundSync(); + DEBUG_END() +} +// virtual bool stopBackgroundSync(const std::string &wallet_password) = 0; +bool WOWNERO_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->stopBackgroundSync(std::string(wallet_password)); + DEBUG_END() +} +// virtual bool isBackgroundSyncing() const = 0; +bool WOWNERO_Wallet_isBackgroundSyncing(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->hasUnknownKeyImages(); + DEBUG_END() +} +// virtual bool isBackgroundWallet() const = 0; +bool WOWNERO_Wallet_isBackgroundWallet(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->isBackgroundWallet(); + DEBUG_END() +} +void* WOWNERO_Wallet_history(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->history(); + DEBUG_END() +} +void* WOWNERO_Wallet_addressBook(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->addressBook(); + DEBUG_END() +} +// virtual Coins * coins() = 0; +void* WOWNERO_Wallet_coins(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->coins(); + DEBUG_END() +} +// virtual Subaddress * subaddress() = 0; +void* WOWNERO_Wallet_subaddress(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->subaddress(); + DEBUG_END() +} +// virtual SubaddressAccount * subaddressAccount() = 0; +void* WOWNERO_Wallet_subaddressAccount(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->subaddressAccount(); + DEBUG_END() +} +// virtual uint32_t defaultMixin() const = 0; +uint32_t WOWNERO_Wallet_defaultMixin(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->defaultMixin(); + DEBUG_END() +} +// virtual void setDefaultMixin(uint32_t arg) = 0; +void WOWNERO_Wallet_setDefaultMixin(void* wallet_ptr, uint32_t arg) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setDefaultMixin(arg); + DEBUG_END() +} +// virtual bool setCacheAttribute(const std::string &key, const std::string &val) = 0; +bool WOWNERO_Wallet_setCacheAttribute(void* wallet_ptr, const char* key, const char* val) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setCacheAttribute(std::string(key), std::string(val)); + DEBUG_END() +} +// virtual std::string getCacheAttribute(const std::string &key) const = 0; +const char* WOWNERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->getCacheAttribute(std::string(key)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual bool setUserNote(const std::string &txid, const std::string ¬e) = 0; +bool WOWNERO_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setUserNote(std::string(txid), std::string(note)); + DEBUG_END() +} +// virtual std::string getUserNote(const std::string &txid) const = 0; +const char* WOWNERO_Wallet_getUserNote(void* wallet_ptr, const char* txid) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->getUserNote(std::string(txid)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* WOWNERO_Wallet_getTxKey(void* wallet_ptr, const char* txid) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->getTxKey(std::string(txid)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +const char* WOWNERO_Wallet_signMessage(void* wallet_ptr, const char* message, const char* address) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = wallet->signMessage(std::string(message), std::string(address)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +bool WOWNERO_Wallet_verifySignedMessage(void* wallet_ptr, const char* message, const char* address, const char* signature) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + bool v = wallet->verifySignedMessage(std::string(message), std::string(address), std::string(signature)); + return v; + DEBUG_END() +} + +bool WOWNERO_Wallet_rescanSpent(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->rescanSpent(); + DEBUG_END() +} + +void WOWNERO_Wallet_setOffline(void* wallet_ptr, bool offline) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->setOffline(offline); + DEBUG_END() +} +// virtual bool isOffline() const = 0; +bool WOWNERO_Wallet_isOffline(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->isOffline(); + DEBUG_END() +} + +void WOWNERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->segregatePreForkOutputs(segregate); + DEBUG_END() +} +// virtual void segregationHeight(uint64_t height) = 0; +void WOWNERO_Wallet_segregationHeight(void* wallet_ptr, uint64_t height) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->segregationHeight(height); + DEBUG_END() +} +// virtual void keyReuseMitigation2(bool mitigation) = 0; +void WOWNERO_Wallet_keyReuseMitigation2(void* wallet_ptr, bool mitigation) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->keyReuseMitigation2(mitigation); + DEBUG_END() +} +// virtual bool lightWalletLogin(bool &isNewWallet) const = 0; +// virtual bool lightWalletImportWalletRequest(std::string &payment_id, uint64_t &fee, bool &new_request, bool &request_fulfilled, std::string &payment_address, std::string &status) = 0; +// virtual bool lockKeysFile() = 0; +bool WOWNERO_Wallet_lockKeysFile(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->lockKeysFile(); + DEBUG_END() +} +// virtual bool unlockKeysFile() = 0; +bool WOWNERO_Wallet_unlockKeysFile(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->unlockKeysFile(); + DEBUG_END() +} +// virtual bool isKeysFileLocked() = 0; +bool WOWNERO_Wallet_isKeysFileLocked(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->isKeysFileLocked(); + DEBUG_END() +} +// virtual Device getDeviceType() const = 0; +int WOWNERO_Wallet_getDeviceType(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->getDeviceType(); + DEBUG_END() +} +// virtual uint64_t coldKeyImageSync(uint64_t &spent, uint64_t &unspent) = 0; +uint64_t WOWNERO_Wallet_coldKeyImageSync(void* wallet_ptr, uint64_t spent, uint64_t unspent) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->coldKeyImageSync(spent, unspent); + DEBUG_END() +} +// virtual void deviceShowAddress(uint32_t accountIndex, uint32_t addressIndex, const std::string &paymentId) = 0; +const char* WOWNERO_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + std::string str = ""; + wallet->deviceShowAddress(accountIndex, addressIndex, str); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// virtual bool reconnectDevice() = 0; +bool WOWNERO_Wallet_reconnectDevice(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->reconnectDevice(); + DEBUG_END() +}; + +uint64_t WOWNERO_Wallet_getBytesReceived(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->getBytesReceived(); + DEBUG_END() +} +uint64_t WOWNERO_Wallet_getBytesSent(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wallet->getBytesSent(); + DEBUG_END() +} + + +void* WOWNERO_WalletManager_createWallet(void* wm_ptr, const char* path, const char* password, const char* language, int networkType) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + Monero::Wallet *wallet = wm->createWallet( + std::string(path), + std::string(password), + std::string(language), + static_cast(networkType)); + return reinterpret_cast(wallet); + DEBUG_END() +} + +void* WOWNERO_WalletManager_openWallet(void* wm_ptr, const char* path, const char* password, int networkType) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + Monero::Wallet *wallet = wm->openWallet( + std::string(path), + std::string(password), + static_cast(networkType)); + return reinterpret_cast(wallet); + DEBUG_END() +} +void* WOWNERO_WalletManager_recoveryWallet(void* wm_ptr, const char* path, const char* password, const char* mnemonic, int networkType, uint64_t restoreHeight, uint64_t kdfRounds, const char* seedOffset) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + // (const std::string &path, const std::string &password, const std::string &mnemonic, + // NetworkType nettype = MAINNET, uint64_t restoreHeight = 0, uint64_t kdf_rounds = 1, + // const std::string &seed_offset = {}) + Monero::Wallet *wallet = wm->recoveryWallet( + std::string(path), + std::string(password), + std::string(mnemonic), + static_cast(networkType), + restoreHeight, + kdfRounds, + std::string(seedOffset)); + return reinterpret_cast(wallet); + DEBUG_END() +} +// virtual Wallet * createWalletFromKeys(const std::string &path, +// const std::string &password, +// const std::string &language, +// NetworkType nettype, +// uint64_t restoreHeight, +// const std::string &addressString, +// const std::string &viewKeyString, +// const std::string &spendKeyString = "", +// uint64_t kdf_rounds = 1) = 0; +void* WOWNERO_WalletManager_createWalletFromKeys(void* wm_ptr, const char* path, const char* password, const char* language, int nettype, uint64_t restoreHeight, const char* addressString, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + Monero::Wallet *wallet = wm->createWalletFromKeys( + std::string(path), + std::string(password), + std::string(language), + static_cast(nettype), + restoreHeight, + std::string(addressString), + std::string(viewKeyString), + std::string(spendKeyString)); + return reinterpret_cast(wallet); + DEBUG_END() +} + +void* WOWNERO_WalletManager_createDeterministicWalletFromSpendKey(void* wm_ptr, const char* path, const char* password, + const char* language, int nettype, uint64_t restoreHeight, + const char* spendKeyString, uint64_t kdf_rounds) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + Monero::Wallet *wallet = wm->createDeterministicWalletFromSpendKey( + std::string(path), + std::string(password), + std::string(language), + static_cast(nettype), + restoreHeight, + std::string(spendKeyString), + kdf_rounds + ); + return reinterpret_cast(wallet); + DEBUG_END() +} + +void* WOWNERO_WalletManager_createWalletFromPolyseed(void* wm_ptr, const char* path, const char* password, + int nettype, const char* mnemonic, const char* passphrase, + bool newWallet, uint64_t restore_height, uint64_t kdf_rounds) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->createWalletFromPolyseed(std::string(path), + std::string(password), + static_cast(nettype), + std::string(mnemonic), + std::string(passphrase), + newWallet, + restore_height, + kdf_rounds); + DEBUG_END() +} + + +bool WOWNERO_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return wm->closeWallet(wallet, store); + DEBUG_END() +} + +bool WOWNERO_WalletManager_walletExists(void* wm_ptr, const char* path) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->walletExists(std::string(path)); + DEBUG_END() +} + +// virtual bool verifyWalletPassword(const std::string &keys_file_name, const std::string &password, bool no_spend_key, uint64_t kdf_rounds = 1) const = 0; +bool WOWNERO_WalletManager_verifyWalletPassword(void* wm_ptr, const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->verifyWalletPassword(std::string(keys_file_name), std::string(password), no_spend_key, kdf_rounds); + DEBUG_END() +} +// virtual bool queryWalletDevice(Wallet::Device& device_type, const std::string &keys_file_name, const std::string &password, uint64_t kdf_rounds = 1) const = 0; +// bool WOWNERO_WalletManager_queryWalletDevice(void* wm_ptr, int device_type, const char* keys_file_name, const char* password, uint64_t kdf_rounds) { +// Monero::WalletManager *wm = reinterpret_cast(wm_ptr); +// return wm->queryWalletDevice(reinterpret_cast(device_type), std::string(keys_file_name), std::string(password), kdf_rounds); +// } +// virtual std::vector findWallets(const std::string &path) = 0; +const char* WOWNERO_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return vectorToString(wm->findWallets(std::string(path)), std::string(separator)); + DEBUG_END() +} + + +const char* WOWNERO_WalletManager_errorString(void* wm_ptr) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + std::string str = wm->errorString(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +void WOWNERO_WalletManager_setDaemonAddress(void* wm_ptr, const char* address) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->setDaemonAddress(std::string(address)); + DEBUG_END() +} + +bool WOWNERO_WalletManager_setProxy(void* wm_ptr, const char* address) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->setProxy(std::string(address)); + DEBUG_END() +} + + +// virtual bool connected(uint32_t *version = NULL) = 0; +// virtual uint64_t blockchainHeight() = 0; +uint64_t WOWNERO_WalletManager_blockchainHeight(void* wm_ptr) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->blockchainHeight(); + DEBUG_END() +} +// virtual uint64_t blockchainTargetHeight() = 0; +uint64_t WOWNERO_WalletManager_blockchainTargetHeight(void* wm_ptr) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->blockchainTargetHeight(); + DEBUG_END() +} +// virtual uint64_t networkDifficulty() = 0; +uint64_t WOWNERO_WalletManager_networkDifficulty(void* wm_ptr) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->networkDifficulty(); + DEBUG_END() +} +// virtual double miningHashRate() = 0; +double WOWNERO_WalletManager_miningHashRate(void* wm_ptr) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->miningHashRate(); + DEBUG_END() +} +// virtual uint64_t blockTarget() = 0; +uint64_t WOWNERO_WalletManager_blockTarget(void* wm_ptr) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->blockTarget(); + DEBUG_END() +} +// virtual bool isMining() = 0; +bool WOWNERO_WalletManager_isMining(void* wm_ptr) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->isMining(); + DEBUG_END() +} +// virtual bool startMining(const std::string &address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true) = 0; +bool WOWNERO_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->startMining(std::string(address), threads, backgroundMining, ignoreBattery); + DEBUG_END() +} +// virtual bool stopMining() = 0; +bool WOWNERO_WalletManager_stopMining(void* wm_ptr, const char* address) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + return wm->stopMining(); + DEBUG_END() +} +// virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0; +const char* WOWNERO_WalletManager_resolveOpenAlias(void* wm_ptr, const char* address, bool dnssec_valid) { + DEBUG_START() + Monero::WalletManager *wm = reinterpret_cast(wm_ptr); + std::string str = wm->resolveOpenAlias(std::string(address), dnssec_valid); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +// WalletManagerFactory + +void* WOWNERO_WalletManagerFactory_getWalletManager() { + DEBUG_START() + Monero::WalletManager *wm = Monero::WalletManagerFactory::getWalletManager(); + return reinterpret_cast(wm); + DEBUG_END() +} + +void WOWNERO_WalletManagerFactory_setLogLevel(int level) { + DEBUG_START() + Monero::WalletManagerFactory::setLogLevel(level); + DEBUG_END() +} + +void WOWNERO_WalletManagerFactory_setLogCategories(const char* categories) { + DEBUG_START() + Monero::WalletManagerFactory::setLogCategories(std::string(categories)); + DEBUG_END() +} + +// DEBUG functions + +// As it turns out we need a bit more functions to make sure that the library is working. +// 0) void +// 1) bool +// 2) int +// 3) uint64_t +// 4) void* +// 5) const char* + +void WOWNERO_DEBUG_test0() { + return; +} + +bool WOWNERO_DEBUG_test1(bool x) { + return x; +} + +int WOWNERO_DEBUG_test2(int x) { + return x; +} + +uint64_t WOWNERO_DEBUG_test3(uint64_t x) { + return x; +} + +void* WOWNERO_DEBUG_test4(uint64_t x) { + int y = x; + return reinterpret_cast(&y); +} + +const char* WOWNERO_DEBUG_test5() { + const char *text = "This is a const char* text"; + return text; +} + +const char* WOWNERO_DEBUG_test5_std() { + std::string text ("This is a std::string text"); + const char *text2 = "This is a text"; + return text2; +} + +bool WOWNERO_DEBUG_isPointerNull(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + return (wallet != NULL); + DEBUG_END() +} + +// cake wallet world +// TODO(mrcyjanek): https://api.dart.dev/stable/3.3.3/dart-ffi/Pointer/fromFunction.html +// callback to dart should be possible..? I mean why not? But I need to +// wait for other implementation (Go preferably) to see if this approach +// will work as expected. +struct WOWNERO_cw_WalletListener; +struct WOWNERO_cw_WalletListener : Monero::WalletListener +{ + uint64_t m_height; + bool m_need_to_refresh; + bool m_new_transaction; + + WOWNERO_cw_WalletListener() + { + m_height = 0; + m_need_to_refresh = false; + m_new_transaction = false; + } + + void moneySpent(const std::string &txId, uint64_t amount) + { + m_new_transaction = true; + } + + void moneyReceived(const std::string &txId, uint64_t amount) + { + m_new_transaction = true; + } + + void unconfirmedMoneyReceived(const std::string &txId, uint64_t amount) + { + m_new_transaction = true; + } + + void newBlock(uint64_t height) + { + m_height = height; + } + + void updated() + { + m_new_transaction = true; + } + + void refreshed() + { + m_need_to_refresh = true; + } + + + void cw_resetNeedToRefresh() + { + m_need_to_refresh = false; + } + + bool cw_isNeedToRefresh() + { + return m_need_to_refresh; + } + + bool cw_isNewTransactionExist() + { + return m_new_transaction; + } + + void cw_resetIsNewTransactionExist() + { + m_new_transaction = false; + } + + uint64_t cw_height() + { + return m_height; + } + + void refreshed(bool success) {}; +}; + +void* WOWNERO_cw_getWalletListener(void* wallet_ptr) { + DEBUG_START() + Monero::Wallet *wallet = reinterpret_cast(wallet_ptr); + WOWNERO_cw_WalletListener *listener = new WOWNERO_cw_WalletListener(); + wallet->setListener(listener); + return reinterpret_cast(listener); + DEBUG_END() +} + +void WOWNERO_cw_WalletListener_resetNeedToRefresh(void* cw_walletListener_ptr) { + DEBUG_START() + WOWNERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); + listener->cw_resetNeedToRefresh(); + DEBUG_END() +} + +bool WOWNERO_cw_WalletListener_isNeedToRefresh(void* cw_walletListener_ptr) { + DEBUG_START() + WOWNERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); + return listener->cw_isNeedToRefresh(); + DEBUG_END() +}; + +bool WOWNERO_cw_WalletListener_isNewTransactionExist(void* cw_walletListener_ptr) { + DEBUG_START() + WOWNERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); + return listener->cw_isNeedToRefresh(); + DEBUG_END() +}; + +void WOWNERO_cw_WalletListener_resetIsNewTransactionExist(void* cw_walletListener_ptr) { + DEBUG_START() + WOWNERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); + listener->cw_isNeedToRefresh(); + DEBUG_END() +}; + +uint64_t WOWNERO_cw_WalletListener_height(void* cw_walletListener_ptr) { + DEBUG_START() + WOWNERO_cw_WalletListener *listener = reinterpret_cast(cw_walletListener_ptr); + return listener->cw_isNeedToRefresh(); + DEBUG_END() +}; + +// 14-word polyseed compat +// wow was really quick to implement polyseed support (aka wownero-seed), which +// results in this maintenance burden we have to go through. +// +// Code is borrowed from +// https://github.com/cypherstack/flutter_libmonero/blob/2c684cedba6c3d9353c7ea748cadb5a246008027/cw_wownero/ios/Classes/wownero_api.cpp#L240 +// this code slightly goes against the way of being simple +void* WOWNERO_deprecated_restore14WordSeed(char *path, char *password, char *seed, int32_t networkType) { + DEBUG_START() + Monero::WalletManager *walletManager = Monero::WalletManagerFactory::getWalletManager(); + try { + Monero::NetworkType _networkType = static_cast(networkType); + + // 14 word seeds /* + wownero_seed wow_seed(seed, "wownero"); + + std::stringstream seed_stream; + seed_stream << wow_seed; + std::string seed_str = seed_stream.str(); + + std::stringstream key_stream; + key_stream << wow_seed.key(); + std::string spendKey = key_stream.str(); + + uint64_t restoreHeight = wow_seed.blockheight(); + + Monero::Wallet *wallet = walletManager->createDeterministicWalletFromSpendKey( + std::string(path), + std::string(password), + "English", + static_cast(_networkType), + (uint64_t)restoreHeight, + spendKey, + 1); + wallet->setCacheAttribute("cake.seed", seed_str); + return reinterpret_cast(wallet); + } catch (...) { + // fallback code so wallet->status() returns at least something.. eh.. + Monero::Wallet *wallet = walletManager->recoveryWallet( + "/", + "", + "invalid mnemonic", + static_cast(networkType), + 0, + 1, + ""); + return reinterpret_cast(wallet); + } + DEBUG_END() +} + +uint64_t WOWNERO_deprecated_14WordSeedHeight(char *seed) { + DEBUG_START() + try { + wownero_seed wow_seed(seed, "wownero"); + return wow_seed.blockheight(); + } catch(...) { + return 1; + } + DEBUG_END() +} + +void* WOWNERO_deprecated_create14WordSeed(char *path, char *password, char *language, int32_t networkType) { + DEBUG_START() + Monero::NetworkType _networkType = static_cast(networkType); + Monero::WalletManager *walletManager = Monero::WalletManagerFactory::getWalletManager(); + + // 14 word seeds /* + time_t time = std::time(nullptr); + wownero_seed wow_seed(time, "wownero"); + + std::stringstream seed_stream; + seed_stream << wow_seed; + std::string seed = seed_stream.str(); + + std::stringstream key_stream; + key_stream << wow_seed.key(); + std::string spendKey = key_stream.str(); + + uint64_t restoreHeight = wow_seed.blockheight(); + + Monero::Wallet *wallet = walletManager->createDeterministicWalletFromSpendKey( + std::string(path), + std::string(password), + std::string(language), + static_cast(_networkType), + (uint64_t)restoreHeight, + spendKey, + 1); + wallet->setCacheAttribute("cake.seed", seed); + return reinterpret_cast(wallet); + DEBUG_END() +} + +const char* WOWNERO_checksum_wallet2_api_c_h() { + return WOWNERO_wallet2_api_c_h_sha256; +} +const char* WOWNERO_checksum_wallet2_api_c_cpp() { + return WOWNERO_wallet2_api_c_cpp_sha256; +} +const char* WOWNERO_checksum_wallet2_api_c_exp() { + return WOWNERO_wallet2_api_c_exp_sha256; +} +// i hate windows + +void WOWNERO_free(void* ptr) { + free(ptr); +} + +#ifdef __cplusplus +} +#endif diff --git a/wownero_libwallet2_api_c/src/main/cpp/wownero_wallet2_api_c.h b/wownero_libwallet2_api_c/src/main/cpp/wownero_wallet2_api_c.h new file mode 100644 index 0000000..f58adcd --- /dev/null +++ b/wownero_libwallet2_api_c/src/main/cpp/wownero_wallet2_api_c.h @@ -0,0 +1,1019 @@ +/* +#include + +#define LOG_TAG "[NDK]" +#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__) +#define LOGW(...) __android_log_print(ANDROID_LOG_WARN,LOG_TAG,__VA_ARGS__) +#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__) +*/ +#include +#include +#include +#include + +#ifdef __cplusplus +extern "C" +{ +#endif + +#ifdef __MINGW32__ + #define ADDAPI __declspec(dllexport) +#else + #define ADDAPI __attribute__((__visibility__("default"))) +#endif + +// namespace Monero { +// enum NetworkType : uint8_t { +// MAINNET = 0, +const int NetworkType_MAINNET = 0; +// TESTNET, +const int NetworkType_TESTNET = 1; +// STAGENET +const int NetworkType_STAGENET = 2; +// }; +// namespace Utils { +// bool isAddressLocal(const std::string &hostaddr); +// void onStartup(); +// } +// template +// class optional { +// public: +// optional(): set(false) {} +// optional(const T &t): t(t), set(true) {} +// const T &operator*() const { return t; } +// T &operator*() { return t; } +// operator bool() const { return set; } +// private: +// T t; +// bool set; +// }; + +// struct PendingTransaction +// { +// enum Status { +// Status_Ok, +const int PendingTransactionStatus_Ok = 0; +// Status_Error, +const int PendingTransactionStatus_Error = 1; +// Status_Critical +const int PendingTransactionStatus_Critical = 2; +// }; +// enum Priority { +// Priority_Default = 0, +const int Priority_Default = 0; +// Priority_Low = 1, +const int Priority_Low = 1; +// Priority_Medium = 2, +const int Priority_Medium = 2; +// Priority_High = 3, +const int Priority_High = 3; +// Priority_Last +const int Priority_Last = 4; +// }; +// virtual ~PendingTransaction() = 0; +// virtual int status() const = 0; +extern ADDAPI int WOWNERO_PendingTransaction_status(void* pendingTx_ptr); +// virtual std::string errorString() const = 0; +extern ADDAPI const char* WOWNERO_PendingTransaction_errorString(void* pendingTx_ptr); +// virtual bool commit(const std::string &filename = "", bool overwrite = false) = 0; +extern ADDAPI bool WOWNERO_PendingTransaction_commit(void* pendingTx_ptr, const char* filename, bool overwrite); +// virtual uint64_t amount() const = 0; +extern ADDAPI uint64_t WOWNERO_PendingTransaction_amount(void* pendingTx_ptr); +// virtual uint64_t dust() const = 0; +extern ADDAPI uint64_t WOWNERO_PendingTransaction_dust(void* pendingTx_ptr); +// virtual uint64_t fee() const = 0; +extern ADDAPI uint64_t WOWNERO_PendingTransaction_fee(void* pendingTx_ptr); +// virtual std::vector txid() const = 0; +extern ADDAPI const char* WOWNERO_PendingTransaction_txid(void* pendingTx_ptr, const char* separator); +// virtual uint64_t txCount() const = 0; +extern ADDAPI uint64_t WOWNERO_PendingTransaction_txCount(void* pendingTx_ptr); +// virtual std::vector subaddrAccount() const = 0; +extern ADDAPI const char* WOWNERO_PendingTransaction_subaddrAccount(void* pendingTx_ptr, const char* separator); +// virtual std::vector> subaddrIndices() const = 0; +extern ADDAPI const char* WOWNERO_PendingTransaction_subaddrIndices(void* pendingTx_ptr, const char* separator); +// virtual std::string multisigSignData() = 0; +extern ADDAPI const char* WOWNERO_PendingTransaction_multisigSignData(void* pendingTx_ptr); +// virtual void signMultisigTx() = 0; +extern ADDAPI void WOWNERO_PendingTransaction_signMultisigTx(void* pendingTx_ptr); +// virtual std::vector signersKeys() const = 0; +extern ADDAPI const char* WOWNERO_PendingTransaction_signersKeys(void* pendingTx_ptr, const char* separator); +// virtual std::vector hex() const = 0; +extern ADDAPI const char* WOWNERO_PendingTransaction_hex(void* pendingTx_ptr, const char* separator); +// virtual std::vector txKey() const = 0; +// extern ADDAPI const char* WOWNERO_PendingTransaction_txHex(void* pendingTx_ptr, const char* separator); +// }; + +// struct UnsignedTransaction +// { +// enum Status { +// Status_Ok, +const int UnsignedTransactionStatus_Ok = 0; +// Status_Error, +const int UnsignedTransactionStatus_Error = 1; +// Status_Critical +const int UnsignedTransactionStatus_Critical = 2; +// }; +// virtual ~UnsignedTransaction() = 0; +// virtual int status() const = 0; +extern ADDAPI int WOWNERO_UnsignedTransaction_status(void* unsignedTx_ptr); +// virtual std::string errorString() const = 0; +extern ADDAPI const char* WOWNERO_UnsignedTransaction_errorString(void* unsignedTx_ptr); +// virtual std::vector amount() const = 0; +extern ADDAPI const char* WOWNERO_UnsignedTransaction_amount(void* unsignedTx_ptr, const char* separator); +// virtual std::vector fee() const = 0; +extern ADDAPI const char* WOWNERO_UnsignedTransaction_fee(void* unsignedTx_ptr, const char* separator); +// virtual std::vector mixin() const = 0; +extern ADDAPI const char* WOWNERO_UnsignedTransaction_mixin(void* unsignedTx_ptr, const char* separator); +// virtual std::string confirmationMessage() const = 0; +extern ADDAPI const char* WOWNERO_UnsignedTransaction_confirmationMessage(void* unsignedTx_ptr); +// virtual std::vector paymentId() const = 0; +extern ADDAPI const char* WOWNERO_UnsignedTransaction_paymentId(void* unsignedTx_ptr, const char* separator); +// virtual std::vector recipientAddress() const = 0; +extern ADDAPI const char* WOWNERO_UnsignedTransaction_recipientAddress(void* unsignedTx_ptr, const char* separator); +// virtual uint64_t minMixinCount() const = 0; +extern ADDAPI uint64_t WOWNERO_UnsignedTransaction_minMixinCount(void* unsignedTx_ptr); +// virtual uint64_t txCount() const = 0; +extern ADDAPI uint64_t WOWNERO_UnsignedTransaction_txCount(void* unsignedTx_ptr); +// virtual bool sign(const std::string &signedFileName) = 0; +extern ADDAPI bool WOWNERO_UnsignedTransaction_sign(void* unsignedTx_ptr, const char* signedFileName); +// }; +// struct TransactionInfo +// { +// enum Direction { +// Direction_In, +const int TransactionInfoDirection_In = 0; +// Direction_Out +const int TransactionInfoDirection_Out = 1; +// }; +// struct Transfer { +// Transfer(uint64_t _amount, const std::string &address); +// const uint64_t amount; +// const std::string address; +// }; +// virtual ~TransactionInfo() = 0; +// virtual int direction() const = 0; +extern ADDAPI int WOWNERO_TransactionInfo_direction(void* txInfo_ptr); +// virtual bool isPending() const = 0; +extern ADDAPI bool WOWNERO_TransactionInfo_isPending(void* txInfo_ptr); +// virtual bool isFailed() const = 0; +extern ADDAPI bool WOWNERO_TransactionInfo_isFailed(void* txInfo_ptr); +// virtual bool isCoinbase() const = 0; +extern ADDAPI bool WOWNERO_TransactionInfo_isCoinbase(void* txInfo_ptr); +// virtual uint64_t amount() const = 0; +extern ADDAPI uint64_t WOWNERO_TransactionInfo_amount(void* txInfo_ptr); +// virtual uint64_t fee() const = 0; +extern ADDAPI uint64_t WOWNERO_TransactionInfo_fee(void* txInfo_ptr); +// virtual uint64_t blockHeight() const = 0; +extern ADDAPI uint64_t WOWNERO_TransactionInfo_blockHeight(void* txInfo_ptr); +// virtual std::string description() const = 0; +extern ADDAPI const char* WOWNERO_TransactionInfo_description(void* txInfo_ptr); +// virtual std::set subaddrIndex() const = 0; +extern ADDAPI const char* WOWNERO_TransactionInfo_subaddrIndex(void* txInfo_ptr, const char* separator); +// virtual uint32_t subaddrAccount() const = 0; +extern ADDAPI uint32_t WOWNERO_TransactionInfo_subaddrAccount(void* txInfo_ptr); +// virtual std::string label() const = 0; +extern ADDAPI const char* WOWNERO_TransactionInfo_label(void* txInfo_ptr); +// virtual uint64_t confirmations() const = 0; +extern ADDAPI uint64_t WOWNERO_TransactionInfo_confirmations(void* txInfo_ptr); +// virtual uint64_t unlockTime() const = 0; +extern ADDAPI uint64_t WOWNERO_TransactionInfo_unlockTime(void* txInfo_ptr); +// virtual std::string hash() const = 0; +extern ADDAPI const char* WOWNERO_TransactionInfo_hash(void* txInfo_ptr); +// virtual std::time_t timestamp() const = 0; +extern ADDAPI uint64_t WOWNERO_TransactionInfo_timestamp(void* txInfo_ptr); +// virtual std::string paymentId() const = 0; +extern ADDAPI const char* WOWNERO_TransactionInfo_paymentId(void* txInfo_ptr); +// virtual const std::vector & transfers() const = 0; +extern ADDAPI int WOWNERO_TransactionInfo_transfers_count(void* txInfo_ptr); +extern ADDAPI uint64_t WOWNERO_TransactionInfo_transfers_amount(void* txInfo_ptr, int index); +extern ADDAPI const char* WOWNERO_TransactionInfo_transfers_address(void* txInfo_ptr, int address); +// }; +// struct TransactionHistory +// { +// virtual ~TransactionHistory() = 0; +// virtual int count() const = 0; +extern ADDAPI int WOWNERO_TransactionHistory_count(void* txHistory_ptr); +// virtual TransactionInfo * transaction(int index) const = 0; +extern ADDAPI void* WOWNERO_TransactionHistory_transaction(void* txHistory_ptr, int index); +// virtual TransactionInfo * transaction(const std::string &id) const = 0; +extern ADDAPI void* WOWNERO_TransactionHistory_transactionById(void* txHistory_ptr, const char* id); +// virtual std::vector getAll() const = 0; +// virtual void refresh() = 0; +extern ADDAPI void WOWNERO_TransactionHistory_refresh(void* txHistory_ptr); +// virtual void setTxNote(const std::string &txid, const std::string ¬e) = 0; +extern ADDAPI void WOWNERO_TransactionHistory_setTxNote(void* txHistory_ptr, const char* txid, const char* note); +// }; +// struct AddressBookRow { +// public: +// AddressBookRow(std::size_t _rowId, const std::string &_address, const std::string &_paymentId, const std::string &_description): +// m_rowId(_rowId), +// m_address(_address), +// m_paymentId(_paymentId), +// m_description(_description) {} + +// private: +// std::size_t m_rowId; +// std::string m_address; +// std::string m_paymentId; +// std::string m_description; +// public: +// std::string extra; +extern ADDAPI const char* WOWNERO_AddressBookRow_extra(void* addressBookRow_ptr); +// std::string getAddress() const {return m_address;} +extern ADDAPI const char* WOWNERO_AddressBookRow_getAddress(void* addressBookRow_ptr); +// std::string getDescription() const {return m_description;} +extern ADDAPI const char* WOWNERO_AddressBookRow_getDescription(void* addressBookRow_ptr); +// std::string getPaymentId() const {return m_paymentId;} +extern ADDAPI const char* WOWNERO_AddressBookRow_getPaymentId(void* addressBookRow_ptr); +// std::size_t getRowId() const {return m_rowId;} +extern ADDAPI size_t WOWNERO_AddressBookRow_getRowId(void* addressBookRow_ptr); +// }; +// struct AddressBook +// { +// enum ErrorCode { +// Status_Ok, +const int AddressBookErrorCodeStatus_Ok = 0; +// General_Error, +const int AddressBookErrorCodeGeneral_Error = 1; +// Invalid_Address, +const int AddressBookErrorCodeInvalid_Address = 2; +// Invalid_Payment_Id +const int AddressBookErrorCodeInvalidPaymentId = 3; +// }; +// virtual ~AddressBook() = 0; +// virtual std::vector getAll() const = 0; +extern ADDAPI int WOWNERO_AddressBook_getAll_size(void* addressBook_ptr); +extern ADDAPI void* WOWNERO_AddressBook_getAll_byIndex(void* addressBook_ptr, int index); +// virtual bool addRow(const std::string &dst_addr , const std::string &payment_id, const std::string &description) = 0; +extern ADDAPI bool WOWNERO_AddressBook_addRow(void* addressBook_ptr, const char* dst_addr , const char* payment_id, const char* description); +// virtual bool deleteRow(std::size_t rowId) = 0; +extern ADDAPI bool WOWNERO_AddressBook_deleteRow(void* addressBook_ptr, size_t rowId); +// virtual bool setDescription(std::size_t index, const std::string &description) = 0; +extern ADDAPI bool WOWNERO_AddressBook_setDescription(void* addressBook_ptr, size_t rowId, const char* description); +// virtual void refresh() = 0; +extern ADDAPI void WOWNERO_AddressBook_refresh(void* addressBook_ptr); +// virtual std::string errorString() const = 0; +extern ADDAPI const char* WOWNERO_AddressBook_errorString(void* addressBook_ptr); +// virtual int errorCode() const = 0; +extern ADDAPI int WOWNERO_AddressBook_errorCode(void* addressBook_ptr); +// virtual int lookupPaymentID(const std::string &payment_id) const = 0; +extern ADDAPI int WOWNERO_AddressBook_lookupPaymentID(void* addressBook_ptr, const char* payment_id); +// }; +// struct CoinsInfo +// { +// virtual ~CoinsInfo() = 0; +// virtual uint64_t blockHeight() const = 0; +extern ADDAPI uint64_t WOWNERO_CoinsInfo_blockHeight(void* coinsInfo_ptr); +// virtual std::string hash() const = 0; +extern ADDAPI const char* WOWNERO_CoinsInfo_hash(void* coinsInfo_ptr); +// virtual size_t internalOutputIndex() const = 0; +extern ADDAPI size_t WOWNERO_CoinsInfo_internalOutputIndex(void* coinsInfo_ptr); +// virtual uint64_t globalOutputIndex() const = 0; +extern ADDAPI uint64_t WOWNERO_CoinsInfo_globalOutputIndex(void* coinsInfo_ptr); +// virtual bool spent() const = 0; +extern ADDAPI bool WOWNERO_CoinsInfo_spent(void* coinsInfo_ptr); +// virtual bool frozen() const = 0; +extern ADDAPI bool WOWNERO_CoinsInfo_frozen(void* coinsInfo_ptr); +// virtual uint64_t spentHeight() const = 0; +extern ADDAPI uint64_t WOWNERO_CoinsInfo_spentHeight(void* coinsInfo_ptr); +// virtual uint64_t amount() const = 0; +extern ADDAPI uint64_t WOWNERO_CoinsInfo_amount(void* coinsInfo_ptr); +// virtual bool rct() const = 0; +extern ADDAPI bool WOWNERO_CoinsInfo_rct(void* coinsInfo_ptr); +// virtual bool keyImageKnown() const = 0; +extern ADDAPI bool WOWNERO_CoinsInfo_keyImageKnown(void* coinsInfo_ptr); +// virtual size_t pkIndex() const = 0; +extern ADDAPI size_t WOWNERO_CoinsInfo_pkIndex(void* coinsInfo_ptr); +// virtual uint32_t subaddrIndex() const = 0; +extern ADDAPI uint32_t WOWNERO_CoinsInfo_subaddrIndex(void* coinsInfo_ptr); +// virtual uint32_t subaddrAccount() const = 0; +extern ADDAPI uint32_t WOWNERO_CoinsInfo_subaddrAccount(void* coinsInfo_ptr); +// virtual std::string address() const = 0; +extern ADDAPI const char* WOWNERO_CoinsInfo_address(void* coinsInfo_ptr); +// virtual std::string addressLabel() const = 0; +extern ADDAPI const char* WOWNERO_CoinsInfo_addressLabel(void* coinsInfo_ptr); +// virtual std::string keyImage() const = 0; +extern ADDAPI const char* WOWNERO_CoinsInfo_keyImage(void* coinsInfo_ptr); +// virtual uint64_t unlockTime() const = 0; +extern ADDAPI uint64_t WOWNERO_CoinsInfo_unlockTime(void* coinsInfo_ptr); +// virtual bool unlocked() const = 0; +extern ADDAPI bool WOWNERO_CoinsInfo_unlocked(void* coinsInfo_ptr); +// virtual std::string pubKey() const = 0; +extern ADDAPI const char* WOWNERO_CoinsInfo_pubKey(void* coinsInfo_ptr); +// virtual bool coinbase() const = 0; +extern ADDAPI bool WOWNERO_CoinsInfo_coinbase(void* coinsInfo_ptr); +// virtual std::string description() const = 0; +extern ADDAPI const char* WOWNERO_CoinsInfo_description(void* coinsInfo_ptr); +// }; +// struct Coins +// { +// virtual ~Coins() = 0; +// virtual int count() const = 0; +extern ADDAPI int WOWNERO_Coins_count(void* coins_ptr); +// virtual CoinsInfo * coin(int index) const = 0; +extern ADDAPI void* WOWNERO_Coins_coin(void* coins_ptr, int index); +// virtual std::vector getAll() const = 0; +extern ADDAPI int WOWNERO_Coins_getAll_size(void* coins_ptr); +extern ADDAPI void* WOWNERO_Coins_getAll_byIndex(void* coins_ptr, int index); +// virtual void refresh() = 0; +extern ADDAPI void WOWNERO_Coins_refresh(void* coins_ptr); +// virtual void setFrozen(std::string public_key) = 0; +extern ADDAPI void WOWNERO_Coins_setFrozenByPublicKey(void* coins_ptr, const char* public_key); +// virtual void setFrozen(int index) = 0; +extern ADDAPI void WOWNERO_Coins_setFrozen(void* coins_ptr, int index); +// virtual void thaw(int index) = 0; +extern ADDAPI void WOWNERO_Coins_thaw(void* coins_ptr, int index); +// virtual void thaw(std::string public_key) = 0; +extern ADDAPI void WOWNERO_Coins_thawByPublicKey(void* coins_ptr, const char* public_key); +// virtual bool isTransferUnlocked(uint64_t unlockTime, uint64_t blockHeight) = 0; +extern ADDAPI bool WOWNERO_Coins_isTransferUnlocked(void* coins_ptr, uint64_t unlockTime, uint64_t blockHeight); +// virtual void setDescription(const std::string &public_key, const std::string &description) = 0; +extern ADDAPI void WOWNERO_Coins_setDescription(void* coins_ptr, const char* public_key, const char* description); +// }; +// struct SubaddressRow { +// public: +// SubaddressRow(std::size_t _rowId, const std::string &_address, const std::string &_label): +// m_rowId(_rowId), +// m_address(_address), +// m_label(_label) {} + +// private: +// std::size_t m_rowId; +// std::string m_address; +// std::string m_label; +// public: +// std::string extra; +extern ADDAPI const char* WOWNERO_SubaddressRow_extra(void* subaddressRow_ptr); +// std::string getAddress() const {return m_address;} +extern ADDAPI const char* WOWNERO_SubaddressRow_getAddress(void* subaddressRow_ptr); +// std::string getLabel() const {return m_label;} +extern ADDAPI const char* WOWNERO_SubaddressRow_getLabel(void* subaddressRow_ptr); +// std::size_t getRowId() const {return m_rowId;} +extern ADDAPI size_t WOWNERO_SubaddressRow_getRowId(void* subaddressRow_ptr); +// }; + +// struct Subaddress +// { +// virtual ~Subaddress() = 0; +// virtual std::vector getAll() const = 0; +extern ADDAPI int WOWNERO_Subaddress_getAll_size(void* subaddress_ptr); +extern ADDAPI void* WOWNERO_Subaddress_getAll_byIndex(void* subaddress_ptr, int index); +// virtual void addRow(uint32_t accountIndex, const std::string &label) = 0; +extern ADDAPI void WOWNERO_Subaddress_addRow(void* subaddress_ptr, uint32_t accountIndex, const char* label); +// virtual void setLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0; +extern ADDAPI void WOWNERO_Subaddress_setLabel(void* subaddress_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label); +// virtual void refresh(uint32_t accountIndex) = 0; +extern ADDAPI void WOWNERO_Subaddress_refresh(void* subaddress_ptr, uint32_t accountIndex); +// }; + +// struct SubaddressAccountRow { +// public: +// SubaddressAccountRow(std::size_t _rowId, const std::string &_address, const std::string &_label, const std::string &_balance, const std::string &_unlockedBalance): +// m_rowId(_rowId), +// m_address(_address), +// m_label(_label), +// m_balance(_balance), +// m_unlockedBalance(_unlockedBalance) {} + +// private: +// std::size_t m_rowId; +// std::string m_address; +// std::string m_label; +// std::string m_balance; +// std::string m_unlockedBalance; +// public: +// std::string extra; +extern ADDAPI const char* WOWNERO_SubaddressAccountRow_extra(void* subaddressAccountRow_ptr); +// std::string getAddress() const {return m_address;} +extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getAddress(void* subaddressAccountRow_ptr); +// std::string getLabel() const {return m_label;} +extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getLabel(void* subaddressAccountRow_ptr); +// std::string getBalance() const {return m_balance;} +extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getBalance(void* subaddressAccountRow_ptr); +// std::string getUnlockedBalance() const {return m_unlockedBalance;} +extern ADDAPI const char* WOWNERO_SubaddressAccountRow_getUnlockedBalance(void* subaddressAccountRow_ptr); +// std::size_t getRowId() const {return m_rowId;} +extern ADDAPI size_t WOWNERO_SubaddressAccountRow_getRowId(void* subaddressAccountRow_ptr); +// }; + +// struct SubaddressAccount +// { +// virtual ~SubaddressAccount() = 0; +// virtual std::vector getAll() const = 0; +extern ADDAPI int WOWNERO_SubaddressAccount_getAll_size(void* subaddressAccount_ptr); +extern ADDAPI void* WOWNERO_SubaddressAccount_getAll_byIndex(void* subaddressAccount_ptr, int index); +// virtual void addRow(const std::string &label) = 0; +extern ADDAPI void WOWNERO_SubaddressAccount_addRow(void* subaddressAccount_ptr, const char* label); +// virtual void setLabel(uint32_t accountIndex, const std::string &label) = 0; +extern ADDAPI void WOWNERO_SubaddressAccount_setLabel(void* subaddressAccount_ptr, uint32_t accountIndex, const char* label); +// virtual void refresh() = 0; +extern ADDAPI void WOWNERO_SubaddressAccount_refresh(void* subaddressAccount_ptr); +// }; + +// struct MultisigState { +// MultisigState() : isMultisig(false), isReady(false), threshold(0), total(0) {} + +// bool isMultisig; +extern ADDAPI bool WOWNERO_MultisigState_isMultisig(void* multisigState_ptr); +// bool isReady; +extern ADDAPI bool WOWNERO_MultisigState_isReady(void* multisigState_ptr); +// uint32_t threshold; +extern ADDAPI uint32_t WOWNERO_MultisigState_threshold(void* multisigState_ptr); +// uint32_t total; +extern ADDAPI uint32_t WOWNERO_MultisigState_total(void* multisigState_ptr); +// }; + + +// struct DeviceProgress { +// DeviceProgress(): m_progress(0), m_indeterminate(false) {} +// DeviceProgress(double progress, bool indeterminate=false): m_progress(progress), m_indeterminate(indeterminate) {} + +// virtual double progress() const { return m_progress; } +extern ADDAPI bool WOWNERO_DeviceProgress_progress(void* deviceProgress_ptr); +// virtual bool indeterminate() const { return m_indeterminate; } +extern ADDAPI bool WOWNERO_DeviceProgress_indeterminate(void* deviceProgress_ptr); + +// protected: +// double m_progress; +// bool m_indeterminate; +// }; + +// struct Wallet; +// struct WalletListener +// { +// virtual ~WalletListener() = 0; +// virtual void moneySpent(const std::string &txId, uint64_t amount) = 0; +// virtual void moneyReceived(const std::string &txId, uint64_t amount) = 0; +// virtual void unconfirmedMoneyReceived(const std::string &txId, uint64_t amount) = 0; +// virtual void newBlock(uint64_t height) = 0; +// virtual void updated() = 0; +// virtual void refreshed() = 0; +// virtual void onDeviceButtonRequest(uint64_t code) { (void)code; } +// virtual void onDeviceButtonPressed() { } +// virtual optional onDevicePinRequest() { +// throw std::runtime_error("Not supported"); +// } +// virtual optional onDevicePassphraseRequest(bool & on_device) { +// on_device = true; +// return optional(); +// } +// virtual void onDeviceProgress(const DeviceProgress & event) { (void)event; }; +// virtual void onSetWallet(Wallet * wallet) { (void)wallet; }; +// }; +// struct Wallet +// { +// enum Device { +// Device_Software = 0, +const int WalletDevice_Software = 0; +// Device_Ledger = 1, +const int WalletDevice_Ledger = 1; +// Device_Trezor = 2 +const int WalletDevice_Trezor = 2; +// }; +// enum Status { +// Status_Ok, +const int WalletStatus_Ok = 0; +// Status_Error, +const int WalletStatus_Error = 1; +// Status_Critical +const int WalletStatus_Critical = 2; +// }; +// enum ConnectionStatus { +// ConnectionStatus_Disconnected, +const int WalletConnectionStatus_Disconnected = 0; +// ConnectionStatus_Connected, +const int WalletConnectionStatus_Connected = 1; +// ConnectionStatus_WrongVersion +const int WalletConnectionStatus_WrongVersion = 2; +// }; +// enum BackgroundSyncType { +// BackgroundSync_Off = 0, +const int WalletBackgroundSync_Off = 0; +// BackgroundSync_ReusePassword = 1, +const int WalletBackgroundSync_ReusePassword = 1; +// BackgroundSync_CustomPassword = 2 +const int BackgroundSync_CustomPassword = 2; +// }; +// virtual ~Wallet() = 0; +// virtual std::string seed(const std::string& seed_offset = "") const = 0; +extern ADDAPI const char* WOWNERO_Wallet_seed(void* wallet_ptr, const char* seed_offset); +// virtual std::string getSeedLanguage() const = 0; +extern ADDAPI const char* WOWNERO_Wallet_getSeedLanguage(void* wallet_ptr); +// virtual void setSeedLanguage(const std::string &arg) = 0; +extern ADDAPI void WOWNERO_Wallet_setSeedLanguage(void* wallet_ptr, const char* arg); +// virtual int status() const = 0; +extern ADDAPI int WOWNERO_Wallet_status(void* wallet_ptr); +// virtual std::string errorString() const = 0; +extern ADDAPI const char* WOWNERO_Wallet_errorString(void* wallet_ptr); +// virtual void statusWithErrorString(int& status, std::string& errorString) const = 0; +// virtual bool setPassword(const std::string &password) = 0; +extern ADDAPI bool WOWNERO_Wallet_setPassword(void* wallet_ptr, const char* password); +// virtual const std::string& getPassword() const = 0; +extern ADDAPI const char* WOWNERO_Wallet_getPassword(void* wallet_ptr); +// virtual bool setDevicePin(const std::string &pin) { (void)pin; return false; }; +extern ADDAPI bool WOWNERO_Wallet_setDevicePin(void* wallet_ptr, const char* pin); +// virtual bool setDevicePassphrase(const std::string &passphrase) { (void)passphrase; return false; }; +extern ADDAPI bool WOWNERO_Wallet_setDevicePassphrase(void* wallet_ptr, const char* passphrase); +// virtual std::string address(uint32_t accountIndex = 0, uint32_t addressIndex = 0) const = 0; +extern ADDAPI const char* WOWNERO_Wallet_address(void* wallet_ptr, uint64_t accountIndex, uint64_t addressIndex); +// std::string mainAddress() const { return address(0, 0); } +// virtual std::string path() const = 0; +extern ADDAPI const char* WOWNERO_Wallet_path(void* wallet_ptr); +// virtual NetworkType nettype() const = 0; +extern ADDAPI int WOWNERO_Wallet_nettype(void* wallet_ptr); +// bool mainnet() const { return nettype() == MAINNET; } +// bool testnet() const { return nettype() == TESTNET; } +// bool stagenet() const { return nettype() == STAGENET; } +// virtual void hardForkInfo(uint8_t &version, uint64_t &earliest_height) const = 0; +// virtual bool useForkRules(uint8_t version, int64_t early_blocks) const = 0; +extern ADDAPI uint8_t WOWNERO_Wallet_useForkRules(void* wallet_ptr, uint8_t version, int64_t early_blocks); +// virtual std::string integratedAddress(const std::string &payment_id) const = 0; +extern ADDAPI const char* WOWNERO_Wallet_integratedAddress(void* wallet_ptr, const char* payment_id); +// virtual std::string secretViewKey() const = 0; +extern ADDAPI const char* WOWNERO_Wallet_secretViewKey(void* wallet_ptr); +// virtual std::string publicViewKey() const = 0; +extern ADDAPI const char* WOWNERO_Wallet_publicViewKey(void* wallet_ptr); +// virtual std::string secretSpendKey() const = 0; +extern ADDAPI const char* WOWNERO_Wallet_secretSpendKey(void* wallet_ptr); +// virtual std::string publicSpendKey() const = 0; +extern ADDAPI const char* WOWNERO_Wallet_publicSpendKey(void* wallet_ptr); +// virtual std::string publicMultisigSignerKey() const = 0; +extern ADDAPI const char* WOWNERO_Wallet_publicMultisigSignerKey(void* wallet_ptr); +// virtual void stop() = 0; +extern ADDAPI void WOWNERO_Wallet_stop(void* wallet_ptr); +// virtual bool store(const std::string &path) = 0; +extern ADDAPI bool WOWNERO_Wallet_store(void* wallet_ptr, const char* path); +// virtual std::string filename() const = 0; +extern ADDAPI const char* WOWNERO_Wallet_filename(void* wallet_ptr); +// virtual std::string keysFilename() const = 0; +extern ADDAPI const char* WOWNERO_Wallet_keysFilename(void* wallet_ptr); +// virtual bool init(const std::string &daemon_address, uint64_t upper_transaction_size_limit = 0, const std::string &daemon_username = "", const std::string &daemon_password = "", bool use_ssl = false, bool lightWallet = false, const std::string &proxy_address = "") = 0; +extern ADDAPI bool WOWNERO_Wallet_init(void* wallet_ptr, const char* daemon_address, uint64_t upper_transaction_size_limit, const char* daemon_username, const char* daemon_password, bool use_ssl, bool lightWallet, const char* proxy_address); +// virtual bool createWatchOnly(const std::string &path, const std::string &password, const std::string &language) const = 0; +extern ADDAPI bool WOWNERO_Wallet_createWatchOnly(void* wallet_ptr, const char* path, const char* password, const char* language); +// virtual void setRefreshFromBlockHeight(uint64_t refresh_from_block_height) = 0; +extern ADDAPI void WOWNERO_Wallet_setRefreshFromBlockHeight(void* wallet_ptr, uint64_t refresh_from_block_height); +// virtual uint64_t getRefreshFromBlockHeight() const = 0; +extern ADDAPI uint64_t WOWNERO_Wallet_getRefreshFromBlockHeight(void* wallet_ptr); +// virtual void setRecoveringFromSeed(bool recoveringFromSeed) = 0; +extern ADDAPI void WOWNERO_Wallet_setRecoveringFromSeed(void* wallet_ptr, bool recoveringFromSeed); +// virtual void setRecoveringFromDevice(bool recoveringFromDevice) = 0; +extern ADDAPI void WOWNERO_Wallet_setRecoveringFromDevice(void* wallet_ptr, bool recoveringFromDevice); +// virtual void setSubaddressLookahead(uint32_t major, uint32_t minor) = 0; +extern ADDAPI void WOWNERO_Wallet_setSubaddressLookahead(void* wallet_ptr, uint32_t major, uint32_t minor); +// virtual bool connectToDaemon() = 0; +extern ADDAPI bool WOWNERO_Wallet_connectToDaemon(void* wallet_ptr); +// virtual ConnectionStatus connected() const = 0; +extern ADDAPI int WOWNERO_Wallet_connected(void* wallet_ptr); +// virtual void setTrustedDaemon(bool arg) = 0; +extern ADDAPI void WOWNERO_Wallet_setTrustedDaemon(void* wallet_ptr, bool arg); +// virtual bool trustedDaemon() const = 0; +extern ADDAPI bool WOWNERO_Wallet_trustedDaemon(void* wallet_ptr); +// virtual bool setProxy(const std::string &address) = 0; +extern ADDAPI bool WOWNERO_Wallet_setProxy(void* wallet_ptr, const char* address); +// virtual uint64_t balance(uint32_t accountIndex = 0) const = 0; +extern ADDAPI uint64_t WOWNERO_Wallet_balance(void* wallet_ptr, uint32_t accountIndex); +// uint64_t balanceAll() const { +// uint64_t result = 0; +// for (uint32_t i = 0; i < numSubaddressAccounts(); ++i) +// result += balance(i); +// return result; +// } +// virtual uint64_t unlockedBalance(uint32_t accountIndex = 0) const = 0; +extern ADDAPI uint64_t WOWNERO_Wallet_unlockedBalance(void* wallet_ptr, uint32_t accountIndex); +// uint64_t unlockedBalanceAll() const { +// uint64_t result = 0; +// for (uint32_t i = 0; i < numSubaddressAccounts(); ++i) +// result += unlockedBalance(i); +// return result; +// } +// virtual bool watchOnly() const = 0; +// virtual uint64_t viewOnlyBalance(uint32_t accountIndex, const std::vector &key_images = {}) const = 0; +extern ADDAPI uint64_t WOWNERO_Wallet_viewOnlyBalance(void* wallet_ptr, uint32_t accountIndex); +extern ADDAPI bool WOWNERO_Wallet_watchOnly(void* wallet_ptr); +// virtual bool isDeterministic() const = 0; +extern ADDAPI bool WOWNERO_Wallet_isDeterministic(void* wallet_ptr); +// virtual uint64_t blockChainHeight() const = 0; +extern ADDAPI uint64_t WOWNERO_Wallet_blockChainHeight(void* wallet_ptr); +// virtual uint64_t approximateBlockChainHeight() const = 0; +extern ADDAPI uint64_t WOWNERO_Wallet_approximateBlockChainHeight(void* wallet_ptr); +// virtual uint64_t estimateBlockChainHeight() const = 0; +extern ADDAPI uint64_t WOWNERO_Wallet_estimateBlockChainHeight(void* wallet_ptr); +// virtual uint64_t daemonBlockChainHeight() const = 0; +extern ADDAPI uint64_t WOWNERO_Wallet_daemonBlockChainHeight(void* wallet_ptr); +// virtual uint64_t daemonBlockChainTargetHeight() const = 0; +extern ADDAPI uint64_t WOWNERO_Wallet_daemonBlockChainTargetHeight(void* wallet_ptr); +// virtual bool synchronized() const = 0; +extern ADDAPI bool WOWNERO_Wallet_synchronized(void* wallet_ptr); +// static std::string displayAmount(uint64_t amount); +extern ADDAPI const char* WOWNERO_Wallet_displayAmount(uint64_t amount); +// static uint64_t amountFromString(const std::string &amount); +extern ADDAPI uint64_t WOWNERO_Wallet_amountFromString(const char* amount); +// static uint64_t amountFromDouble(double amount); +extern ADDAPI uint64_t WOWNERO_Wallet_amountFromDouble(double amount); +// static std::string genPaymentId(); +extern ADDAPI const char* WOWNERO_Wallet_genPaymentId(); +// static bool paymentIdValid(const std::string &paiment_id); +extern ADDAPI bool WOWNERO_Wallet_paymentIdValid(const char* paiment_id); +// static bool addressValid(const std::string &str, NetworkType nettype); +extern ADDAPI bool WOWNERO_Wallet_addressValid(const char* str, int nettype); +// static bool addressValid(const std::string &str, bool testnet) // deprecated +// { +// return addressValid(str, testnet ? TESTNET : MAINNET); +// } +extern ADDAPI bool WOWNERO_Wallet_keyValid(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype); +extern ADDAPI const char* WOWNERO_Wallet_keyValid_error(const char* secret_key_string, const char* address_string, bool isViewKey, int nettype); +// static bool keyValid(const std::string &secret_key_string, const std::string &address_string, bool isViewKey, NetworkType nettype, std::string &error); +// static bool keyValid(const std::string &secret_key_string, const std::string &address_string, bool isViewKey, bool testnet, std::string &error) // deprecated +// { +// return keyValid(secret_key_string, address_string, isViewKey, testnet ? TESTNET : MAINNET, error); +// } +// static std::string paymentIdFromAddress(const std::string &str, NetworkType nettype); +extern ADDAPI const char* WOWNERO_Wallet_paymentIdFromAddress(const char* strarg, int nettype); +// static std::string paymentIdFromAddress(const std::string &str, bool testnet) // deprecated +// { +// return paymentIdFromAddress(str, testnet ? TESTNET : MAINNET); +// } +// static uint64_t maximumAllowedAmount(); +extern ADDAPI uint64_t WOWNERO_Wallet_maximumAllowedAmount(); +// static void init(const char *argv0, const char *default_log_base_name) { init(argv0, default_log_base_name, "", true); } +// static void init(const char *argv0, const char *default_log_base_name, const std::string &log_path, bool console); +extern ADDAPI void WOWNERO_Wallet_init3(void* wallet_ptr, const char* argv0, const char* default_log_base_name, const char* log_path, bool console); +// static void debug(const std::string &category, const std::string &str); +// static void info(const std::string &category, const std::string &str); +// static void warning(const std::string &category, const std::string &str); +// static void error(const std::string &category, const std::string &str); +// virtual void startRefresh() = 0; +// virtual bool getPolyseed(std::string &seed, std::string &passphrase) const = 0; +extern ADDAPI const char* WOWNERO_Wallet_getPolyseed(void* wallet_ptr, const char* passphrase); +// static bool createPolyseed(std::string &seed_words, std::string &err, const std::string &language = "English"); +extern ADDAPI const char* WOWNERO_Wallet_createPolyseed(const char* language); +extern ADDAPI void WOWNERO_Wallet_startRefresh(void* wallet_ptr); +// virtual void pauseRefresh() = 0; +extern ADDAPI void WOWNERO_Wallet_pauseRefresh(void* wallet_ptr); +// virtual bool refresh() = 0; +extern ADDAPI bool WOWNERO_Wallet_refresh(void* wallet_ptr); +// virtual void refreshAsync() = 0; +extern ADDAPI void WOWNERO_Wallet_refreshAsync(void* wallet_ptr); +// virtual bool rescanBlockchain() = 0; +extern ADDAPI bool WOWNERO_Wallet_rescanBlockchain(void* wallet_ptr); +// virtual void rescanBlockchainAsync() = 0; +extern ADDAPI void WOWNERO_Wallet_rescanBlockchainAsync(void* wallet_ptr); +// virtual void setAutoRefreshInterval(int millis) = 0; +extern ADDAPI void WOWNERO_Wallet_setAutoRefreshInterval(void* wallet_ptr, int millis); +// virtual int autoRefreshInterval() const = 0; +extern ADDAPI int WOWNERO_Wallet_autoRefreshInterval(void* wallet_ptr); +// virtual void addSubaddressAccount(const std::string& label) = 0; +extern ADDAPI void WOWNERO_Wallet_addSubaddressAccount(void* wallet_ptr, const char* label); +// virtual size_t numSubaddressAccounts() const = 0; +extern ADDAPI size_t WOWNERO_Wallet_numSubaddressAccounts(void* wallet_ptr); +// virtual size_t numSubaddresses(uint32_t accountIndex) const = 0; +extern ADDAPI size_t WOWNERO_Wallet_numSubaddresses(void* wallet_ptr, uint32_t accountIndex); +// virtual void addSubaddress(uint32_t accountIndex, const std::string& label) = 0; +extern ADDAPI void WOWNERO_Wallet_addSubaddress(void* wallet_ptr, uint32_t accountIndex, const char* label); +// virtual std::string getSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex) const = 0; +extern ADDAPI const char* WOWNERO_Wallet_getSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex); +// virtual void setSubaddressLabel(uint32_t accountIndex, uint32_t addressIndex, const std::string &label) = 0; +extern ADDAPI void WOWNERO_Wallet_setSubaddressLabel(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex, const char* label); +// virtual MultisigState multisig() const = 0; +// virtual std::string getMultisigInfo() const = 0; +extern ADDAPI const char* WOWNERO_Wallet_getMultisigInfo(void* wallet_ptr); +// virtual std::string makeMultisig(const std::vector& info, uint32_t threshold) = 0; +// virtual std::string exchangeMultisigKeys(const std::vector &info, const bool force_update_use_with_caution) = 0; +// virtual bool exportMultisigImages(std::string& images) = 0; +// virtual size_t importMultisigImages(const std::vector& images) = 0; +// virtual bool hasMultisigPartialKeyImages() const = 0; +// virtual PendingTransaction* restoreMultisigTransaction(const std::string& signData) = 0; +// virtual PendingTransaction * createTransactionMultDest(const std::vector &dst_addr, const std::string &payment_id, +// optional> amount, uint32_t mixin_count, +// PendingTransaction::Priority = PendingTransaction::Priority_Low, +// uint32_t subaddr_account = 0, +// std::set subaddr_indices = {}) = 0; +extern ADDAPI void* WOWNERO_Wallet_createTransactionMultDest(void* wallet_ptr, const char* dst_addr_list, const char* dst_addr_list_separator, const char* payment_id, + bool amount_sweep_all, const char* amount_list, const char* amount_list_separator, uint32_t mixin_count, + int pendingTransactionPriority, + uint32_t subaddr_account, + const char* preferredInputs, const char* preferredInputs_separator); +// virtual PendingTransaction * createTransaction(const std::string &dst_addr, const std::string &payment_id, +// optional amount, uint32_t mixin_count, +// PendingTransaction::Priority = PendingTransaction::Priority_Low, +// uint32_t subaddr_account = 0, +// std::set subaddr_indices = {}, +// const std::set &preferred_inputs = {) = 0; +extern ADDAPI void* WOWNERO_Wallet_createTransaction(void* wallet_ptr, const char* dst_addr, const char* payment_id, + uint64_t amount, uint32_t mixin_count, + int pendingTransactionPriority, + uint32_t subaddr_account, + const char* preferredInputs, const char* separator); +// virtual PendingTransaction * createSweepUnmixableTransaction() = 0; +// virtual UnsignedTransaction * loadUnsignedTx(const std::string &unsigned_filename) = 0; +extern ADDAPI void* WOWNERO_Wallet_loadUnsignedTx(void* wallet_ptr, const char* unsigned_filename); +// virtual bool submitTransaction(const std::string &fileName) = 0; +extern ADDAPI bool WOWNERO_Wallet_submitTransaction(void* wallet_ptr, const char* fileName); +// virtual void disposeTransaction(PendingTransaction * t) = 0; +// virtual uint64_t estimateTransactionFee(const std::vector> &destinations, +// PendingTransaction::Priority priority) const = 0; +// virtual bool hasUnknownKeyImages() const = 0; +extern ADDAPI bool WOWNERO_Wallet_hasUnknownKeyImages(void* wallet_ptr); +// virtual bool exportKeyImages(const std::string &filename, bool all = false) = 0; +extern ADDAPI bool WOWNERO_Wallet_exportKeyImages(void* wallet_ptr, const char* filename, bool all); +// virtual bool importKeyImages(const std::string &filename) = 0; +extern ADDAPI bool WOWNERO_Wallet_importKeyImages(void* wallet_ptr, const char* filename); +// virtual bool exportOutputs(const std::string &filename, bool all = false) = 0; +extern ADDAPI bool WOWNERO_Wallet_exportOutputs(void* wallet_ptr, const char* filename, bool all); +// virtual bool importOutputs(const std::string &filename) = 0; +extern ADDAPI bool WOWNERO_Wallet_importOutputs(void* wallet_ptr, const char* filename); +// virtual bool scanTransactions(const std::vector &txids) = 0; +// virtual bool setupBackgroundSync(const BackgroundSyncType background_sync_type, const std::string &wallet_password, const optional &background_cache_password) = 0; +extern ADDAPI bool WOWNERO_Wallet_setupBackgroundSync(void* wallet_ptr, int background_sync_type, const char* wallet_password, const char* background_cache_password); +// virtual BackgroundSyncType getBackgroundSyncType() const = 0; +extern ADDAPI int WOWNERO_Wallet_getBackgroundSyncType(void* wallet_ptr); +// virtual bool startBackgroundSync() = 0; +extern ADDAPI bool WOWNERO_Wallet_startBackgroundSync(void* wallet_ptr); +// virtual bool stopBackgroundSync(const std::string &wallet_password) = 0; +extern ADDAPI bool WOWNERO_Wallet_stopBackgroundSync(void* wallet_ptr, const char* wallet_password); +// virtual bool isBackgroundSyncing() const = 0; +extern ADDAPI bool WOWNERO_Wallet_isBackgroundSyncing(void* wallet_ptr); +// virtual bool isBackgroundWallet() const = 0; +extern ADDAPI bool WOWNERO_Wallet_isBackgroundWallet(void* wallet_ptr); +// virtual TransactionHistory * history() = 0; +extern ADDAPI void* WOWNERO_Wallet_history(void* wallet_ptr); +// virtual AddressBook * addressBook() = 0; +extern ADDAPI void* WOWNERO_Wallet_addressBook(void* wallet_ptr); +// virtual Coins * coins() = 0; +extern ADDAPI void* WOWNERO_Wallet_coins(void* wallet_ptr); +// virtual Subaddress * subaddress() = 0; +extern ADDAPI void* WOWNERO_Wallet_subaddress(void* wallet_ptr); +// virtual SubaddressAccount * subaddressAccount() = 0; +extern ADDAPI void* WOWNERO_Wallet_subaddressAccount(void* wallet_ptr); +// virtual void setListener(WalletListener *) = 0; +// virtual uint32_t defaultMixin() const = 0; +extern ADDAPI uint32_t WOWNERO_Wallet_defaultMixin(void* wallet_ptr); +// virtual void setDefaultMixin(uint32_t arg) = 0; +extern ADDAPI void WOWNERO_Wallet_setDefaultMixin(void* wallet_ptr, uint32_t arg); +// virtual bool setCacheAttribute(const std::string &key, const std::string &val) = 0; +extern ADDAPI bool WOWNERO_Wallet_setCacheAttribute(void* wallet_ptr, const char* key, const char* val); +// virtual std::string getCacheAttribute(const std::string &key) const = 0; +extern ADDAPI const char* WOWNERO_Wallet_getCacheAttribute(void* wallet_ptr, const char* key); +// virtual bool setUserNote(const std::string &txid, const std::string ¬e) = 0; +extern ADDAPI bool WOWNERO_Wallet_setUserNote(void* wallet_ptr, const char* txid, const char* note); +// virtual std::string getUserNote(const std::string &txid) const = 0; +extern ADDAPI const char* WOWNERO_Wallet_getUserNote(void* wallet_ptr, const char* txid); +// virtual std::string getTxKey(const std::string &txid) const = 0; +extern ADDAPI const char* WOWNERO_Wallet_getTxKey(void* wallet_ptr, const char* txid); +// virtual bool checkTxKey(const std::string &txid, std::string tx_key, const std::string &address, uint64_t &received, bool &in_pool, uint64_t &confirmations) = 0; +// virtual std::string getTxProof(const std::string &txid, const std::string &address, const std::string &message) const = 0; +// virtual bool checkTxProof(const std::string &txid, const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &received, bool &in_pool, uint64_t &confirmations) = 0; +// virtual std::string getSpendProof(const std::string &txid, const std::string &message) const = 0; +// virtual bool checkSpendProof(const std::string &txid, const std::string &message, const std::string &signature, bool &good) const = 0; +// virtual std::string getReserveProof(bool all, uint32_t account_index, uint64_t amount, const std::string &message) const = 0; +// virtual bool checkReserveProof(const std::string &address, const std::string &message, const std::string &signature, bool &good, uint64_t &total, uint64_t &spent) const = 0; +// virtual std::string signMessage(const std::string &message, const std::string &address = "") = 0; +extern ADDAPI const char* WOWNERO_Wallet_signMessage(void* wallet_ptr, const char* message, const char* address); +// virtual bool verifySignedMessage(const std::string &message, const std::string &addres, const std::string &signature) const = 0; +extern ADDAPI bool WOWNERO_Wallet_verifySignedMessage(void* wallet_ptr, const char* message, const char* address, const char* signature); +// virtual std::string signMultisigParticipant(const std::string &message) const = 0; +// virtual bool verifyMessageWithPublicKey(const std::string &message, const std::string &publicKey, const std::string &signature) const = 0; +// virtual bool parse_uri(const std::string &uri, std::string &address, std::string &payment_id, uint64_t &amount, std::string &tx_description, std::string &recipient_name, std::vector &unknown_parameters, std::string &error) = 0; +// virtual std::string make_uri(const std::string &address, const std::string &payment_id, uint64_t amount, const std::string &tx_description, const std::string &recipient_name, std::string &error) const = 0; +// virtual std::string getDefaultDataDir() const = 0; +// virtual bool rescanSpent() = 0; +extern ADDAPI bool WOWNERO_Wallet_rescanSpent(void* wallet_ptr); +// virtual void setOffline(bool offline) = 0; +extern ADDAPI void WOWNERO_Wallet_setOffline(void* wallet_ptr, bool offline); +// virtual bool isOffline() const = 0; +extern ADDAPI bool WOWNERO_Wallet_isOffline(void* wallet_ptr); +// virtual bool blackballOutputs(const std::vector &outputs, bool add) = 0; +// virtual bool blackballOutput(const std::string &amount, const std::string &offset) = 0; +// virtual bool unblackballOutput(const std::string &amount, const std::string &offset) = 0; +// virtual bool getRing(const std::string &key_image, std::vector &ring) const = 0; +// virtual bool getRings(const std::string &txid, std::vector>> &rings) const = 0; +// virtual bool setRing(const std::string &key_image, const std::vector &ring, bool relative) = 0; +// virtual void segregatePreForkOutputs(bool segregate) = 0; +extern ADDAPI void WOWNERO_Wallet_segregatePreForkOutputs(void* wallet_ptr, bool segregate); +// virtual void segregationHeight(uint64_t height) = 0; +extern ADDAPI void WOWNERO_Wallet_segregationHeight(void* wallet_ptr, uint64_t height); +// virtual void keyReuseMitigation2(bool mitigation) = 0; +extern ADDAPI void WOWNERO_Wallet_keyReuseMitigation2(void* wallet_ptr, bool mitigation); +// virtual bool lightWalletLogin(bool &isNewWallet) const = 0; +// virtual bool lightWalletImportWalletRequest(std::string &payment_id, uint64_t &fee, bool &new_request, bool &request_fulfilled, std::string &payment_address, std::string &status) = 0; +// virtual bool lockKeysFile() = 0; +extern ADDAPI bool WOWNERO_Wallet_lockKeysFile(void* wallet_ptr); +// virtual bool unlockKeysFile() = 0; +extern ADDAPI bool WOWNERO_Wallet_unlockKeysFile(void* wallet_ptr); +// virtual bool isKeysFileLocked() = 0; +extern ADDAPI bool WOWNERO_Wallet_isKeysFileLocked(void* wallet_ptr); +// virtual Device getDeviceType() const = 0; +extern ADDAPI int WOWNERO_Wallet_getDeviceType(void* wallet_ptr); +// virtual uint64_t coldKeyImageSync(uint64_t &spent, uint64_t &unspent) = 0; +extern ADDAPI uint64_t WOWNERO_Wallet_coldKeyImageSync(void* wallet_ptr, uint64_t spent, uint64_t unspent); +// virtual void deviceShowAddress(uint32_t accountIndex, uint32_t addressIndex, const std::string &paymentId) = 0; +extern ADDAPI const char* WOWNERO_Wallet_deviceShowAddress(void* wallet_ptr, uint32_t accountIndex, uint32_t addressIndex); +// virtual bool reconnectDevice() = 0; +extern ADDAPI bool WOWNERO_Wallet_reconnectDevice(void* wallet_ptr); +// virtual uint64_t getBytesReceived() = 0; +extern ADDAPI uint64_t WOWNERO_Wallet_getBytesReceived(void* wallet_ptr); +// virtual uint64_t getBytesSent() = 0; +extern ADDAPI uint64_t WOWNERO_Wallet_getBytesSent(void* wallet_ptr); +// }; + +// struct WalletManager +// { +// virtual Wallet * createWallet(const std::string &path, const std::string &password, const std::string &language, NetworkType nettype, uint64_t kdf_rounds = 1) = 0; +extern ADDAPI void* WOWNERO_WalletManager_createWallet(void* wm_ptr, const char* path, const char* password, const char* language, int networkType); +// Wallet * createWallet(const std::string &path, const std::string &password, const std::string &language, bool testnet = false) // deprecated +// { +// return createWallet(path, password, language, testnet ? TESTNET : MAINNET); +// } +// virtual Wallet * openWallet(const std::string &path, const std::string &password, NetworkType nettype, uint64_t kdf_rounds = 1, WalletListener * listener = nullptr) = 0; +extern ADDAPI void* WOWNERO_WalletManager_openWallet(void* wm_ptr, const char* path, const char* password, int networkType); +// Wallet * openWallet(const std::string &path, const std::string &password, bool testnet = false) // deprecated +// { +// return openWallet(path, password, testnet ? TESTNET : MAINNET); +// } +// virtual Wallet * recoveryWallet(const std::string &path, const std::string &password, const std::string &mnemonic, +// NetworkType nettype = MAINNET, uint64_t restoreHeight = 0, uint64_t kdf_rounds = 1, +// const std::string &seed_offset = {}) = 0; +extern ADDAPI void* WOWNERO_WalletManager_recoveryWallet(void* wm_ptr, const char* path, const char* password, const char* mnemonic, int networkType, uint64_t restoreHeight, uint64_t kdfRounds, const char* seedOffset); +// Wallet * recoveryWallet(const std::string &path, const std::string &password, const std::string &mnemonic, +// bool testnet = false, uint64_t restoreHeight = 0) // deprecated +// { +// return recoveryWallet(path, password, mnemonic, testnet ? TESTNET : MAINNET, restoreHeight); +// } +// virtual Wallet * recoveryWallet(const std::string &path, const std::string &mnemonic, NetworkType nettype, uint64_t restoreHeight = 0) = 0; +// Wallet * recoveryWallet(const std::string &path, const std::string &mnemonic, bool testnet = false, uint64_t restoreHeight = 0) // deprecated +// { +// return recoveryWallet(path, mnemonic, testnet ? TESTNET : MAINNET, restoreHeight); +// } +// virtual Wallet * createWalletFromKeys(const std::string &path, +// const std::string &password, +// const std::string &language, +// NetworkType nettype, +// uint64_t restoreHeight, +// const std::string &addressString, +// const std::string &viewKeyString, +// const std::string &spendKeyString = "", +// uint64_t kdf_rounds = 1) = 0; +extern ADDAPI void* WOWNERO_WalletManager_createWalletFromKeys(void* wm_ptr, const char* path, const char* password, const char* language, int nettype, uint64_t restoreHeight, const char* addressString, const char* viewKeyString, const char* spendKeyString, uint64_t kdf_rounds); +// Wallet * createWalletFromKeys(const std::string &path, +// const std::string &password, +// const std::string &language, +// bool testnet, +// uint64_t restoreHeight, +// const std::string &addressString, +// const std::string &viewKeyString, +// const std::string &spendKeyString = "") // deprecated +// { +// return createWalletFromKeys(path, password, language, testnet ? TESTNET : MAINNET, restoreHeight, addressString, viewKeyString, spendKeyString); +// } +// virtual Wallet * createWalletFromKeys(const std::string &path, +// const std::string &language, +// NetworkType nettype, +// uint64_t restoreHeight, +// const std::string &addressString, +// const std::string &viewKeyString, +// const std::string &spendKeyString = "") = 0; +// Wallet * createWalletFromKeys(const std::string &path, +// const std::string &language, +// bool testnet, +// uint64_t restoreHeight, +// const std::string &addressString, +// const std::string &viewKeyString, +// const std::string &spendKeyString = "") // deprecated +// { +// return createWalletFromKeys(path, language, testnet ? TESTNET : MAINNET, restoreHeight, addressString, viewKeyString, spendKeyString); +// } +// virtual Wallet * createDeterministicWalletFromSpendKey(const std::string &path, +// const std::string &password, +// const std::string &language, +// NetworkType nettype, +// uint64_t restoreHeight, +// const std::string &spendKeyString, +// uint64_t kdf_rounds = 1) = 0; +extern ADDAPI void* WOWNERO_WalletManager_createDeterministicWalletFromSpendKey(void* wm_ptr, const char* path, const char* password, + const char* language, int nettype, uint64_t restoreHeight, + const char* spendKeyString, uint64_t kdf_rounds); +// virtual Wallet * createWalletFromDevice(const std::string &path, +// const std::string &password, +// NetworkType nettype, +// const std::string &deviceName, +// uint64_t restoreHeight = 0, +// const std::string &subaddressLookahead = "", +// uint64_t kdf_rounds = 1, +// WalletListener * listener = nullptr) = 0; +// virtual Wallet * createWalletFromPolyseed(const std::string &path, +// const std::string &password, +// NetworkType nettype, +// const std::string &mnemonic, +// const std::string &passphrase = "", +// bool newWallet = true, +// uint64_t restore_height = 0, +// uint64_t kdf_rounds = 1) = 0; +extern ADDAPI void* WOWNERO_WalletManager_createWalletFromPolyseed(void* wm_ptr, const char* path, const char* password, + int nettype, const char* mnemonic, const char* passphrase, + bool newWallet, uint64_t restore_height, uint64_t kdf_rounds); +// virtual bool closeWallet(Wallet *wallet, bool store = true) = 0; +extern ADDAPI bool WOWNERO_WalletManager_closeWallet(void* wm_ptr, void* wallet_ptr, bool store); +// virtual bool walletExists(const std::string &path) = 0; +extern ADDAPI bool WOWNERO_WalletManager_walletExists(void* wm_ptr, const char* path); +// virtual bool verifyWalletPassword(const std::string &keys_file_name, const std::string &password, bool no_spend_key, uint64_t kdf_rounds = 1) const = 0; +extern ADDAPI bool WOWNERO_WalletManager_verifyWalletPassword(void* wm_ptr, const char* keys_file_name, const char* password, bool no_spend_key, uint64_t kdf_rounds); +// virtual bool queryWalletDevice(Wallet::Device& device_type, const std::string &keys_file_name, const std::string &password, uint64_t kdf_rounds = 1) const = 0; +// extern ADDAPI bool WOWNERO_WalletManager_queryWalletDevice(void* wm_ptr, int device_type, const char* keys_file_name, const char* password, uint64_t kdf_rounds); +// virtual std::vector findWallets(const std::string &path) = 0; +extern ADDAPI const char* WOWNERO_WalletManager_findWallets(void* wm_ptr, const char* path, const char* separator); +// virtual std::string errorString() const = 0; +extern ADDAPI const char* WOWNERO_WalletManager_errorString(void* wm_ptr); +// virtual void setDaemonAddress(const std::string &address) = 0; +extern ADDAPI void WOWNERO_WalletManager_setDaemonAddress(void* wm_ptr, const char* address); +// virtual bool connected(uint32_t *version = NULL) = 0; +// virtual uint64_t blockchainHeight() = 0; +extern ADDAPI uint64_t WOWNERO_WalletManager_blockchainHeight(void* wm_ptr); +// virtual uint64_t blockchainTargetHeight() = 0; +extern ADDAPI uint64_t WOWNERO_WalletManager_blockchainTargetHeight(void* wm_ptr); +// virtual uint64_t networkDifficulty() = 0; +extern ADDAPI uint64_t WOWNERO_WalletManager_networkDifficulty(void* wm_ptr); +// virtual double miningHashRate() = 0; +extern ADDAPI double WOWNERO_WalletManager_miningHashRate(void* wm_ptr); +// virtual uint64_t blockTarget() = 0; +extern ADDAPI uint64_t WOWNERO_WalletManager_blockTarget(void* wm_ptr); +// virtual bool isMining() = 0; +extern ADDAPI bool WOWNERO_WalletManager_isMining(void* wm_ptr); +// virtual bool startMining(const std::string &address, uint32_t threads = 1, bool background_mining = false, bool ignore_battery = true) = 0; +extern ADDAPI bool WOWNERO_WalletManager_startMining(void* wm_ptr, const char* address, uint32_t threads, bool backgroundMining, bool ignoreBattery); +// virtual bool stopMining() = 0; +extern ADDAPI bool WOWNERO_WalletManager_stopMining(void* wm_ptr, const char* address); +// virtual std::string resolveOpenAlias(const std::string &address, bool &dnssec_valid) const = 0; +extern ADDAPI const char* WOWNERO_WalletManager_resolveOpenAlias(void* wm_ptr, const char* address, bool dnssec_valid); +// static std::tuple checkUpdates( +// const std::string &software, +// std::string subdir, +// const char *buildtag = nullptr, +// const char *current_version = nullptr); +// virtual bool setProxy(const std::string &address) = 0; +extern ADDAPI bool WOWNERO_WalletManager_setProxy(void* wm_ptr, const char* address); +// }; + +int LogLevel_Silent = -1; +int LogLevel_0 = 0; +int LogLevel_1 = 1; +int LogLevel_2 = 2; +int LogLevel_3 = 3; +int LogLevel_4 = 4; +int LogLevel_Min = -1; +int LogLevel_Max = 4; + +// struct WalletManagerFactory +// { +// enum LogLevel { +// LogLevel_Silent = -1, +// LogLevel_0 = 0, +// LogLevel_1 = 1, +// LogLevel_2 = 2, +// LogLevel_3 = 3, +// LogLevel_4 = 4, +// LogLevel_Min = LogLevel_Silent, +// LogLevel_Max = LogLevel_4 +// }; +// static WalletManager * getWalletManager(); +extern ADDAPI void* WOWNERO_WalletManagerFactory_getWalletManager(); +// static void setLogLevel(int level); +extern ADDAPI void WOWNERO_WalletManagerFactory_setLogLevel(int level); +// static void setLogCategories(const std::string &categories); +extern ADDAPI void WOWNERO_WalletManagerFactory_setLogCategories(const char* categories); +// }; +// } + +extern ADDAPI void WOWNERO_DEBUG_test0(); +extern ADDAPI bool WOWNERO_DEBUG_test1(bool x); +extern ADDAPI int WOWNERO_DEBUG_test2(int x); +extern ADDAPI uint64_t WOWNERO_DEBUG_test3(uint64_t x); +extern ADDAPI void* WOWNERO_DEBUG_test4(uint64_t x); +extern ADDAPI const char* WOWNERO_DEBUG_test5(); +extern ADDAPI const char* WOWNERO_DEBUG_test5_std(); +extern ADDAPI bool WOWNERO_DEBUG_isPointerNull(void* wallet_ptr); + +// cake world + +extern ADDAPI void* WOWNERO_cw_getWalletListener(void* wallet_ptr); +extern ADDAPI void WOWNERO_cw_WalletListener_resetNeedToRefresh(void* cw_walletListener_ptr); +extern ADDAPI bool WOWNERO_cw_WalletListener_isNeedToRefresh(void* cw_walletListener_ptr); +extern ADDAPI bool WOWNERO_cw_WalletListener_isNewTransactionExist(void* cw_walletListener_ptr); +extern ADDAPI void WOWNERO_cw_WalletListener_resetIsNewTransactionExist(void* cw_walletListener_ptr); +extern ADDAPI uint64_t WOWNERO_cw_WalletListener_height(void* cw_walletListener_ptr); + +// legacy + +extern ADDAPI void* WOWNERO_deprecated_restore14WordSeed(char *path, char *password, char *seed, int32_t networkType); +extern ADDAPI void* WOWNERO_deprecated_create14WordSeed(char *path, char *password, char *language, int32_t networkType); +extern ADDAPI uint64_t WOWNERO_deprecated_14WordSeedHeight(char *seed); + +extern ADDAPI void WOWNERO_free(void* ptr); + +extern ADDAPI const char* WOWNERO_checksum_wallet2_api_c_h(); +extern ADDAPI const char* WOWNERO_checksum_wallet2_api_c_cpp(); +extern ADDAPI const char* WOWNERO_checksum_wallet2_api_c_exp(); + +#ifdef __cplusplus +} +#endif \ No newline at end of file diff --git a/zano_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp b/zano_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp deleted file mode 100644 index 11acc0a..0000000 --- a/zano_libwallet2_api_c/src/main/cpp/wallet2_api_c.cpp +++ /dev/null @@ -1,322 +0,0 @@ -#include -#include "wallet2_api_c.h" -#include -#include -#include -#include "zano_checksum.h" -#include "helpers.hpp" -#include "../../../../zano/src/wallet/plain_wallet_api.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - - -// namespace plain_wallet -// { -// typedef int64_t hwallet; -// std::string init(const std::string& address, const std::string& working_dir, int log_level); -const char* ZANO_PlainWallet_init(const char* address, const char* working_dir, int log_level) { - DEBUG_START() - std::string str = plain_wallet::init(std::string(address), std::string(working_dir), log_level); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string init(const std::string& ip, const std::string& port, const std::string& working_dir, int log_level); -const char* ZANO_PlainWallet_init2(const char* ip, const char* port, const char* working_dir, int log_level) { - DEBUG_START() - std::string str = plain_wallet::init(std::string(ip), std::string(port), std::string(working_dir), log_level); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string reset(); -const char* ZANO_PlainWallet_reset() { - DEBUG_START() - std::string str = plain_wallet::reset(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string set_log_level(int log_level); -const char* ZANO_PlainWallet_setLogLevel(int log_level) { - DEBUG_START() - std::string str = plain_wallet::set_log_level(log_level); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string get_version(); -const char* ZANO_PlainWallet_getVersion() { - DEBUG_START() - std::string str = plain_wallet::get_version(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string get_wallet_files(); -const char* ZANO_PlainWallet_getWalletFiles() { - DEBUG_START() - std::string str = plain_wallet::get_wallet_files(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string get_export_private_info(const std::string& target_dir); -const char* ZANO_PlainWallet_getExportPrivateInfo(const char* target_dir) { - DEBUG_START() - std::string str = plain_wallet::get_export_private_info(std::string(target_dir)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string delete_wallet(const std::string& file_name); -const char* ZANO_PlainWallet_deleteWallet(const char* file_name) { - DEBUG_START() - std::string str = plain_wallet::delete_wallet(std::string(file_name)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string get_address_info(const std::string& addr); -const char* ZANO_PlainWallet_getAddressInfo(const char* addr) { - DEBUG_START() - std::string str = plain_wallet::get_address_info(std::string(addr)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string get_appconfig(const std::string& encryption_key); -const char* ZANO_PlainWallet_getAppconfig(const char* encryption_key) { - DEBUG_START() - std::string str = plain_wallet::get_appconfig(std::string(encryption_key)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string set_appconfig(const std::string& conf_str, const std::string& encryption_key); -const char* ZANO_PlainWallet_setAppconfig(const char* conf_str, const char* encryption_key) { - DEBUG_START() - std::string str = plain_wallet::set_appconfig(std::string(conf_str), std::string(encryption_key)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string generate_random_key(uint64_t lenght); -const char* ZANO_PlainWallet_generateRandomKey(uint64_t lenght) { - DEBUG_START() - std::string str = plain_wallet::generate_random_key(lenght); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string get_logs_buffer(); -const char* ZANO_PlainWallet_getLogsBuffer() { - DEBUG_START() - std::string str = plain_wallet::get_logs_buffer(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string truncate_log(); -const char* ZANO_PlainWallet_truncateLog() { - DEBUG_START() - std::string str = plain_wallet::truncate_log(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string get_connectivity_status(); -const char* ZANO_PlainWallet_getConnectivityStatus() { - DEBUG_START() - std::string str = plain_wallet::get_connectivity_status(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string open(const std::string& path, const std::string& password); -const char* ZANO_PlainWallet_open(const char* path, const char* password) { - DEBUG_START() - std::string str = plain_wallet::open(std::string(path), std::string(password)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string restore(const std::string& seed, const std::string& path, const std::string& password, const std::string& seed_password); -const char* ZANO_PlainWallet_restore(const char* seed, const char* path, const char* password, const char* seed_password) { - DEBUG_START() - std::string str = plain_wallet::restore(std::string(seed), std::string(path), std::string(password), std::string(seed_password)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string generate(const std::string& path, const std::string& password); -const char* ZANO_PlainWallet_generate(const char* path, const char* password) { - DEBUG_START() - std::string str = plain_wallet::generate(std::string(path), std::string(password)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string get_opened_wallets(); -const char* ZANO_PlainWallet_getOpenWallets() { - DEBUG_START() - std::string str = plain_wallet::get_opened_wallets(); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} - -// std::string get_wallet_status(hwallet h); -const char* ZANO_PlainWallet_getWalletStatus(int64_t h) { - DEBUG_START() - std::string str = plain_wallet::get_wallet_status(h); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string close_wallet(hwallet h); -const char* ZANO_PlainWallet_closeWallet(int64_t h) { - DEBUG_START() - std::string str = plain_wallet::close_wallet(h); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string invoke(hwallet h, const std::string& params); -const char* ZANO_PlainWallet_invoke(int64_t h, const char* params) { - DEBUG_START() - std::string str = plain_wallet::invoke(h, std::string(params)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// //async api -// std::string async_call(const std::string& method_name, uint64_t instance_id, const std::string& params); -const char* ZANO_PlainWallet_asyncCall(const char* method_name, uint64_t instance_id, const char* params) { - DEBUG_START() - std::string str = plain_wallet::async_call(std::string(method_name), instance_id, std::string(params)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string try_pull_result(uint64_t); -const char* ZANO_PlainWallet_tryPullResult(uint64_t instance_id) { - DEBUG_START() - std::string str = plain_wallet::try_pull_result(instance_id); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string sync_call(const std::string& method_name, uint64_t instance_id, const std::string& params); -const char* ZANO_PlainWallet_syncCall(const char* method_name, uint64_t instance_id, const char* params) { - DEBUG_START() - std::string str = plain_wallet::sync_call(std::string(method_name), instance_id, std::string(params)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// //cake wallet api extension -// bool is_wallet_exist(const std::string& path); -bool ZANO_PlainWallet_isWalletExist(const char* path) { - DEBUG_START() - return plain_wallet::is_wallet_exist(std::string(path)); - DEBUG_END() -} -// std::string get_wallet_info(hwallet h); -const char* ZANO_PlainWallet_getWalletInfo(int64_t h) { - DEBUG_START() - std::string str = plain_wallet::get_wallet_info(h); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// std::string reset_wallet_password(hwallet h, const std::string& password); -const char* ZANO_PlainWallet_resetWalletPassword(int64_t h, const char* password) { - DEBUG_START() - std::string str = plain_wallet::reset_wallet_password(h, std::string(password)); - const std::string::size_type size = str.size(); - char *buffer = new char[size + 1]; //we need extra char for NUL - memcpy(buffer, str.c_str(), size + 1); - return buffer; - DEBUG_END() -} -// uint64_t get_current_tx_fee(uint64_t priority); // 0 (default), 1 (unimportant), 2 (normal), 3 (elevated), 4 (priority) -uint64_t ZANO_PlainWallet_getCurrentTxFee(uint64_t priority) { - DEBUG_START() - return plain_wallet::get_current_tx_fee(priority); - DEBUG_END() -} -// } - -void ZANO_free(void* ptr) { - free(ptr); -} - -const char* ZANO_checksum_wallet2_api_c_h() { - return ZANO_wallet2_api_c_h_sha256; -} -const char* ZANO_checksum_wallet2_api_c_cpp() { - return ZANO_wallet2_api_c_cpp_sha256; -} -const char* ZANO_checksum_wallet2_api_c_exp() { - return ZANO_wallet2_api_c_exp_sha256; -} - -#ifdef __cplusplus -} -#endif diff --git a/zano_libwallet2_api_c/src/main/cpp/wallet2_api_c.h b/zano_libwallet2_api_c/src/main/cpp/wallet2_api_c.h deleted file mode 100644 index df6d3ef..0000000 --- a/zano_libwallet2_api_c/src/main/cpp/wallet2_api_c.h +++ /dev/null @@ -1,67 +0,0 @@ -/* -#include - -#define LOG_TAG "[NDK]" -#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__) -#define LOGW(...) __android_log_print(ANDROID_LOG_WARN,LOG_TAG,__VA_ARGS__) -#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__) -*/ -#include -#include -#include -#include -#include "zano_checksum.h" - -#ifdef __cplusplus -extern "C" -{ -#endif - -#ifdef __MINGW32__ - #define ADDAPI __declspec(dllexport) -#else - #define ADDAPI __attribute__((__visibility__("default"))) -#endif - - -extern ADDAPI const char* ZANO_PlainWallet_init(const char* address, const char* working_dir, int log_level); -extern ADDAPI const char* ZANO_PlainWallet_init2(const char* ip, const char* port, const char* working_dir, int log_level); -extern ADDAPI const char* ZANO_PlainWallet_reset(); -extern ADDAPI const char* ZANO_PlainWallet_setLogLevel(int log_level); -extern ADDAPI const char* ZANO_PlainWallet_getVersion(); -extern ADDAPI const char* ZANO_PlainWallet_getWalletFiles(); -extern ADDAPI const char* ZANO_PlainWallet_getExportPrivateInfo(const char* target_dir); -extern ADDAPI const char* ZANO_PlainWallet_deleteWallet(const char* file_name); -extern ADDAPI const char* ZANO_PlainWallet_getAddressInfo(const char* addr); -extern ADDAPI const char* ZANO_PlainWallet_getAppconfig(const char* encryption_key); -extern ADDAPI const char* ZANO_PlainWallet_setAppconfig(const char* conf_str, const char* encryption_key); -extern ADDAPI const char* ZANO_PlainWallet_generateRandomKey(uint64_t lenght); -extern ADDAPI const char* ZANO_PlainWallet_getLogsBuffer(); -extern ADDAPI const char* ZANO_PlainWallet_truncateLog(); -extern ADDAPI const char* ZANO_PlainWallet_getConnectivityStatus(); -extern ADDAPI const char* ZANO_PlainWallet_open(const char* path, const char* password); -extern ADDAPI const char* ZANO_PlainWallet_restore(const char* seed, const char* path, const char* password, const char* seed_password); -extern ADDAPI const char* ZANO_PlainWallet_generate(const char* path, const char* password); -extern ADDAPI const char* ZANO_PlainWallet_getOpenWallets(); -extern ADDAPI const char* ZANO_PlainWallet_getWalletStatus(int64_t h); -extern ADDAPI const char* ZANO_PlainWallet_closeWallet(int64_t h); -extern ADDAPI const char* ZANO_PlainWallet_invoke(int64_t h, const char* params); - - -extern ADDAPI const char* ZANO_PlainWallet_asyncCall(const char* method_name, uint64_t instance_id, const char* params); -extern ADDAPI const char* ZANO_PlainWallet_tryPullResult(uint64_t instance_id); -extern ADDAPI const char* ZANO_PlainWallet_syncCall(const char* method_name, uint64_t instance_id, const char* params); -extern ADDAPI bool ZANO_PlainWallet_isWalletExist(const char* path); -extern ADDAPI const char* ZANO_PlainWallet_getWalletInfo(int64_t h); -extern ADDAPI const char* ZANO_PlainWallet_resetWalletPassword(int64_t h, const char* password); -extern ADDAPI uint64_t ZANO_PlainWallet_getCurrentTxFee(uint64_t priority); - -extern ADDAPI void ZANO_free(void* ptr); - -extern ADDAPI const char* ZANO_checksum_wallet2_api_c_h(); -extern ADDAPI const char* ZANO_checksum_wallet2_api_c_cpp(); -extern ADDAPI const char* ZANO_checksum_wallet2_api_c_exp(); - -#ifdef __cplusplus -} -#endif diff --git a/zano_libwallet2_api_c/src/main/cpp/zano_checksum.c b/zano_libwallet2_api_c/src/main/cpp/zano_checksum.c new file mode 100644 index 0000000..4d6dd4d --- /dev/null +++ b/zano_libwallet2_api_c/src/main/cpp/zano_checksum.c @@ -0,0 +1,5 @@ +#include "zano_checksum.h" + +const char * ZANO_wallet2_api_c_h_sha256 = "8acaa95513b85a984c08e05cc3f2ac7530bb8f32946eeeb45357bd846aef33dd"; +const char * ZANO_wallet2_api_c_cpp_sha256 = "326c2b134918db2f139075e8051e2531725689e5a672496792684d5fd35dd156-b372a99c7ada82caac53b677d9aaa7c0902e3b0b"; +const char * ZANO_wallet2_api_c_exp_sha256 = "66f3ff655bbfd11ad28c318ab707090b5a93276f436b06f7b1c0f329dba3c9c2"; diff --git a/zano_libwallet2_api_c/src/main/cpp/zano_wallet2_api_c.cpp b/zano_libwallet2_api_c/src/main/cpp/zano_wallet2_api_c.cpp new file mode 100644 index 0000000..b60ba56 --- /dev/null +++ b/zano_libwallet2_api_c/src/main/cpp/zano_wallet2_api_c.cpp @@ -0,0 +1,322 @@ +#include +#include "zano_wallet2_api_c.h" +#include +#include +#include +#include "zano_checksum.h" +#include "helpers.hpp" +#include "../../../../zano/src/wallet/plain_wallet_api.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + + +// namespace plain_wallet +// { +// typedef int64_t hwallet; +// std::string init(const std::string& address, const std::string& working_dir, int log_level); +const char* ZANO_PlainWallet_init(const char* address, const char* working_dir, int log_level) { + DEBUG_START() + std::string str = plain_wallet::init(std::string(address), std::string(working_dir), log_level); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string init(const std::string& ip, const std::string& port, const std::string& working_dir, int log_level); +const char* ZANO_PlainWallet_init2(const char* ip, const char* port, const char* working_dir, int log_level) { + DEBUG_START() + std::string str = plain_wallet::init(std::string(ip), std::string(port), std::string(working_dir), log_level); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string reset(); +const char* ZANO_PlainWallet_reset() { + DEBUG_START() + std::string str = plain_wallet::reset(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string set_log_level(int log_level); +const char* ZANO_PlainWallet_setLogLevel(int log_level) { + DEBUG_START() + std::string str = plain_wallet::set_log_level(log_level); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string get_version(); +const char* ZANO_PlainWallet_getVersion() { + DEBUG_START() + std::string str = plain_wallet::get_version(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string get_wallet_files(); +const char* ZANO_PlainWallet_getWalletFiles() { + DEBUG_START() + std::string str = plain_wallet::get_wallet_files(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string get_export_private_info(const std::string& target_dir); +const char* ZANO_PlainWallet_getExportPrivateInfo(const char* target_dir) { + DEBUG_START() + std::string str = plain_wallet::get_export_private_info(std::string(target_dir)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string delete_wallet(const std::string& file_name); +const char* ZANO_PlainWallet_deleteWallet(const char* file_name) { + DEBUG_START() + std::string str = plain_wallet::delete_wallet(std::string(file_name)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string get_address_info(const std::string& addr); +const char* ZANO_PlainWallet_getAddressInfo(const char* addr) { + DEBUG_START() + std::string str = plain_wallet::get_address_info(std::string(addr)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string get_appconfig(const std::string& encryption_key); +const char* ZANO_PlainWallet_getAppconfig(const char* encryption_key) { + DEBUG_START() + std::string str = plain_wallet::get_appconfig(std::string(encryption_key)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string set_appconfig(const std::string& conf_str, const std::string& encryption_key); +const char* ZANO_PlainWallet_setAppconfig(const char* conf_str, const char* encryption_key) { + DEBUG_START() + std::string str = plain_wallet::set_appconfig(std::string(conf_str), std::string(encryption_key)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string generate_random_key(uint64_t lenght); +const char* ZANO_PlainWallet_generateRandomKey(uint64_t lenght) { + DEBUG_START() + std::string str = plain_wallet::generate_random_key(lenght); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string get_logs_buffer(); +const char* ZANO_PlainWallet_getLogsBuffer() { + DEBUG_START() + std::string str = plain_wallet::get_logs_buffer(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string truncate_log(); +const char* ZANO_PlainWallet_truncateLog() { + DEBUG_START() + std::string str = plain_wallet::truncate_log(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string get_connectivity_status(); +const char* ZANO_PlainWallet_getConnectivityStatus() { + DEBUG_START() + std::string str = plain_wallet::get_connectivity_status(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string open(const std::string& path, const std::string& password); +const char* ZANO_PlainWallet_open(const char* path, const char* password) { + DEBUG_START() + std::string str = plain_wallet::open(std::string(path), std::string(password)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string restore(const std::string& seed, const std::string& path, const std::string& password, const std::string& seed_password); +const char* ZANO_PlainWallet_restore(const char* seed, const char* path, const char* password, const char* seed_password) { + DEBUG_START() + std::string str = plain_wallet::restore(std::string(seed), std::string(path), std::string(password), std::string(seed_password)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string generate(const std::string& path, const std::string& password); +const char* ZANO_PlainWallet_generate(const char* path, const char* password) { + DEBUG_START() + std::string str = plain_wallet::generate(std::string(path), std::string(password)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string get_opened_wallets(); +const char* ZANO_PlainWallet_getOpenWallets() { + DEBUG_START() + std::string str = plain_wallet::get_opened_wallets(); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} + +// std::string get_wallet_status(hwallet h); +const char* ZANO_PlainWallet_getWalletStatus(int64_t h) { + DEBUG_START() + std::string str = plain_wallet::get_wallet_status(h); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string close_wallet(hwallet h); +const char* ZANO_PlainWallet_closeWallet(int64_t h) { + DEBUG_START() + std::string str = plain_wallet::close_wallet(h); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string invoke(hwallet h, const std::string& params); +const char* ZANO_PlainWallet_invoke(int64_t h, const char* params) { + DEBUG_START() + std::string str = plain_wallet::invoke(h, std::string(params)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// //async api +// std::string async_call(const std::string& method_name, uint64_t instance_id, const std::string& params); +const char* ZANO_PlainWallet_asyncCall(const char* method_name, uint64_t instance_id, const char* params) { + DEBUG_START() + std::string str = plain_wallet::async_call(std::string(method_name), instance_id, std::string(params)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string try_pull_result(uint64_t); +const char* ZANO_PlainWallet_tryPullResult(uint64_t instance_id) { + DEBUG_START() + std::string str = plain_wallet::try_pull_result(instance_id); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string sync_call(const std::string& method_name, uint64_t instance_id, const std::string& params); +const char* ZANO_PlainWallet_syncCall(const char* method_name, uint64_t instance_id, const char* params) { + DEBUG_START() + std::string str = plain_wallet::sync_call(std::string(method_name), instance_id, std::string(params)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// //cake wallet api extension +// bool is_wallet_exist(const std::string& path); +bool ZANO_PlainWallet_isWalletExist(const char* path) { + DEBUG_START() + return plain_wallet::is_wallet_exist(std::string(path)); + DEBUG_END() +} +// std::string get_wallet_info(hwallet h); +const char* ZANO_PlainWallet_getWalletInfo(int64_t h) { + DEBUG_START() + std::string str = plain_wallet::get_wallet_info(h); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// std::string reset_wallet_password(hwallet h, const std::string& password); +const char* ZANO_PlainWallet_resetWalletPassword(int64_t h, const char* password) { + DEBUG_START() + std::string str = plain_wallet::reset_wallet_password(h, std::string(password)); + const std::string::size_type size = str.size(); + char *buffer = new char[size + 1]; //we need extra char for NUL + memcpy(buffer, str.c_str(), size + 1); + return buffer; + DEBUG_END() +} +// uint64_t get_current_tx_fee(uint64_t priority); // 0 (default), 1 (unimportant), 2 (normal), 3 (elevated), 4 (priority) +uint64_t ZANO_PlainWallet_getCurrentTxFee(uint64_t priority) { + DEBUG_START() + return plain_wallet::get_current_tx_fee(priority); + DEBUG_END() +} +// } + +void ZANO_free(void* ptr) { + free(ptr); +} + +const char* ZANO_checksum_wallet2_api_c_h() { + return ZANO_wallet2_api_c_h_sha256; +} +const char* ZANO_checksum_wallet2_api_c_cpp() { + return ZANO_wallet2_api_c_cpp_sha256; +} +const char* ZANO_checksum_wallet2_api_c_exp() { + return ZANO_wallet2_api_c_exp_sha256; +} + +#ifdef __cplusplus +} +#endif diff --git a/zano_libwallet2_api_c/src/main/cpp/zano_wallet2_api_c.h b/zano_libwallet2_api_c/src/main/cpp/zano_wallet2_api_c.h new file mode 100644 index 0000000..df6d3ef --- /dev/null +++ b/zano_libwallet2_api_c/src/main/cpp/zano_wallet2_api_c.h @@ -0,0 +1,67 @@ +/* +#include + +#define LOG_TAG "[NDK]" +#define LOGI(...) __android_log_print(ANDROID_LOG_INFO,LOG_TAG,__VA_ARGS__) +#define LOGW(...) __android_log_print(ANDROID_LOG_WARN,LOG_TAG,__VA_ARGS__) +#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR,LOG_TAG,__VA_ARGS__) +*/ +#include +#include +#include +#include +#include "zano_checksum.h" + +#ifdef __cplusplus +extern "C" +{ +#endif + +#ifdef __MINGW32__ + #define ADDAPI __declspec(dllexport) +#else + #define ADDAPI __attribute__((__visibility__("default"))) +#endif + + +extern ADDAPI const char* ZANO_PlainWallet_init(const char* address, const char* working_dir, int log_level); +extern ADDAPI const char* ZANO_PlainWallet_init2(const char* ip, const char* port, const char* working_dir, int log_level); +extern ADDAPI const char* ZANO_PlainWallet_reset(); +extern ADDAPI const char* ZANO_PlainWallet_setLogLevel(int log_level); +extern ADDAPI const char* ZANO_PlainWallet_getVersion(); +extern ADDAPI const char* ZANO_PlainWallet_getWalletFiles(); +extern ADDAPI const char* ZANO_PlainWallet_getExportPrivateInfo(const char* target_dir); +extern ADDAPI const char* ZANO_PlainWallet_deleteWallet(const char* file_name); +extern ADDAPI const char* ZANO_PlainWallet_getAddressInfo(const char* addr); +extern ADDAPI const char* ZANO_PlainWallet_getAppconfig(const char* encryption_key); +extern ADDAPI const char* ZANO_PlainWallet_setAppconfig(const char* conf_str, const char* encryption_key); +extern ADDAPI const char* ZANO_PlainWallet_generateRandomKey(uint64_t lenght); +extern ADDAPI const char* ZANO_PlainWallet_getLogsBuffer(); +extern ADDAPI const char* ZANO_PlainWallet_truncateLog(); +extern ADDAPI const char* ZANO_PlainWallet_getConnectivityStatus(); +extern ADDAPI const char* ZANO_PlainWallet_open(const char* path, const char* password); +extern ADDAPI const char* ZANO_PlainWallet_restore(const char* seed, const char* path, const char* password, const char* seed_password); +extern ADDAPI const char* ZANO_PlainWallet_generate(const char* path, const char* password); +extern ADDAPI const char* ZANO_PlainWallet_getOpenWallets(); +extern ADDAPI const char* ZANO_PlainWallet_getWalletStatus(int64_t h); +extern ADDAPI const char* ZANO_PlainWallet_closeWallet(int64_t h); +extern ADDAPI const char* ZANO_PlainWallet_invoke(int64_t h, const char* params); + + +extern ADDAPI const char* ZANO_PlainWallet_asyncCall(const char* method_name, uint64_t instance_id, const char* params); +extern ADDAPI const char* ZANO_PlainWallet_tryPullResult(uint64_t instance_id); +extern ADDAPI const char* ZANO_PlainWallet_syncCall(const char* method_name, uint64_t instance_id, const char* params); +extern ADDAPI bool ZANO_PlainWallet_isWalletExist(const char* path); +extern ADDAPI const char* ZANO_PlainWallet_getWalletInfo(int64_t h); +extern ADDAPI const char* ZANO_PlainWallet_resetWalletPassword(int64_t h, const char* password); +extern ADDAPI uint64_t ZANO_PlainWallet_getCurrentTxFee(uint64_t priority); + +extern ADDAPI void ZANO_free(void* ptr); + +extern ADDAPI const char* ZANO_checksum_wallet2_api_c_h(); +extern ADDAPI const char* ZANO_checksum_wallet2_api_c_cpp(); +extern ADDAPI const char* ZANO_checksum_wallet2_api_c_exp(); + +#ifdef __cplusplus +} +#endif -- cgit v1.2.3