diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md index 5862e7ce..46f4ac9e 100644 --- a/.github/ISSUE_TEMPLATE.md +++ b/.github/ISSUE_TEMPLATE.md @@ -14,9 +14,9 @@ support. BUG BOUNTY REPORT INFORMATION --------------------------------------------------- -In the interest of further improving the security of the network, we have launched the RaiBlocks Bug Bounty Program. +In the interest of further improving the security of the network, we have launched the Nano Bug Bounty Program. -WARNING! Don't disclose any information for the Raiblocks bug bounty. First, please read the article about our Bug Bounty Program. +WARNING! Don't disclose any information for the Nano bug bounty. First, please read the article about our Bug Bounty Program. https://www.reddit.com/r/RaiBlocks/comments/7makm7/announcing_the_raiblocks_bug_bounty_program/ @@ -70,10 +70,10 @@ Briefly describe the problem you are having in a few paragraphs. diff --git a/.gitignore b/.gitignore index 5be957c0..c9d9bd6a 100644 --- a/.gitignore +++ b/.gitignore @@ -30,8 +30,8 @@ core_test !core_test/ qt_test -rai_node -rai_wallet +nano_node +nano_wallet slow_test # IDEs diff --git a/.gitlab-ci.yml b/.gitlab-ci.yml index e27d2fef..fd50a40e 100644 --- a/.gitlab-ci.yml +++ b/.gitlab-ci.yml @@ -1,4 +1,4 @@ -## Raiblocks CI config +## Nano CI config image: ubuntu:xenial diff --git a/CMakeLists.txt b/CMakeLists.txt index 68a7ea58..720123ad 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -1,5 +1,5 @@ cmake_minimum_required (VERSION 3.4) -project (rai) +project (nano-core) set (CPACK_PACKAGE_VERSION_MAJOR "18") set (CPACK_PACKAGE_VERSION_MINOR "0") @@ -13,16 +13,16 @@ set(CMAKE_INSTALL_RPATH "@executable_path/../Frameworks") # Create all libraries and executables in the root binary dir set(CMAKE_RUNTIME_OUTPUT_DIRECTORY ${CMAKE_BINARY_DIR}) -set (RAIBLOCKS_GUI OFF CACHE BOOL "") -set (RAIBLOCKS_TEST OFF CACHE BOOL "") -set (RAIBLOCKS_SECURE_RPC OFF CACHE BOOL "") +set (NANO_GUI OFF CACHE BOOL "") +set (NANO_TEST OFF CACHE BOOL "") +set (NANO_SECURE_RPC OFF CACHE BOOL "") -option(RAIBLOCKS_ASAN_INT "Enable ASan+UBSan+Integer overflow" OFF) -option(RAIBLOCKS_ASAN "Enable ASan+UBSan" OFF) -option(RAIBLOCKS_SIMD_OPTIMIZATIONS "Enable CPU-specific SIMD optimizations (SSE/AVX or NEON, e.g.)" OFF) +option(NANO_ASAN_INT "Enable ASan+UBSan+Integer overflow" OFF) +option(NANO_ASAN "Enable ASan+UBSan" OFF) +option(NANO_SIMD_OPTIMIZATIONS "Enable CPU-specific SIMD optimizations (SSE/AVX or NEON, e.g.)" OFF) -SET (ACTIVE_NETWORK rai_live_network CACHE STRING "Selects which network parameters are used") -set_property (CACHE ACTIVE_NETWORK PROPERTY STRINGS rai_test_network rai_beta_network rai_live_network) +SET (ACTIVE_NETWORK nano_live_network CACHE STRING "Selects which network parameters are used") +set_property (CACHE ACTIVE_NETWORK PROPERTY STRINGS nano_test_network nano_beta_network nano_live_network) if(NOT CMAKE_BUILD_TYPE) set(CMAKE_BUILD_TYPE "Release" CACHE STRING "Choose the type of build, options are: Debug Release RelWithDebInfo MinSizeRel." FORCE) @@ -41,19 +41,19 @@ if (WIN32) -DMINIUPNP_STATICLIB) else () add_compile_options(-Werror=switch) - if (RAIBLOCKS_ASAN) + if (NANO_ASAN OR RAIBLOCKS_ASAN) add_compile_options(-fsanitize=address,undefined) add_definitions(-DED25519_NO_INLINE_ASM) - elseif (RAIBLOCKS_ASAN_INT) + elseif (NANO_ASAN_INT OR RAIBLOCKS_ASAN_INT) add_compile_options(-fsanitize=address,undefined,integer) add_definitions(-DED25519_NO_INLINE_ASM) - elseif (RAIBLOCKS_TSAN) + elseif (NANO_TSAN OR RAIBLOCKS_TSAN) add_compile_options(-fsanitize=thread) add_definitions(-DED25519_NO_INLINE_ASM) endif() IF (CMAKE_SYSTEM_PROCESSOR MATCHES "^(i.86|x86(_64)?)$") - if (RAIBLOCKS_SIMD_OPTIMIZATIONS) + if (NANO_SIMD_OPTIMIZATIONS OR RAIBLOCKS_SIMD_OPTIMIZATIONS) add_compile_options(-msse4) elseif(CMAKE_SYSTEM_PROCESSOR STREQUAL "x86_64") add_compile_options(-msse2) @@ -88,21 +88,21 @@ elseif (WIN32) set (PLATFORM_LINK_FLAGS "") else () set (PLATFORM_LINK_FLAGS "-static-libgcc -static-libstdc++") - if (RAIBLOCKS_ASAN) + if (NANO_ASAN OR RAIBLOCKS_ASAN) set (PLATFORM_LINK_FLAGS "${PLATFORM_LINK_FLAGS} -fsanitize=address,undefined") - elseif (RAIBLOCKS_ASAN_INT) + elseif (NANO_ASAN_INT OR RAIBLOCKS_ASAN_INT) set (PLATFORM_LINK_FLAGS "${PLATFORM_LINK_FLAGS} -fsanitize=address,undefined,integer") - elseif (RAIBLOCKS_TSAN) + elseif (NANO_TSAN OR RAIBLOCKS_TSAN) set (PLATFORM_LINK_FLAGS "${PLATFORM_LINK_FLAGS} -fsanitize=thread") endif() endif () SET( CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} ${PLATFORM_LINK_FLAGS}" ) -if (RAIBLOCKS_SECURE_RPC) +if (NANO_SECURE_RPC OR RAIBLOCKS_SECURE_RPC) find_package (OpenSSL 1.0 REQUIRED) include_directories(${OPENSSL_INCLUDE_DIR}) - add_definitions (-DRAIBLOCKS_SECURE_RPC) + add_definitions (-DNANO_SECURE_RPC) message("OpenSSL include dir: ${OPENSSL_INCLUDE_DIR}") message("OpenSSL libraries: ${OPENSSL_LIBRARIES}") message("OpenSSL lib: ${OPENSSL_SSL_LIBRARY}") @@ -134,7 +134,7 @@ set_target_properties(libminiupnpc-static PROPERTIES INTERFACE_INCLUDE_DIRECTORI set (BUILD_SHARED OFF CACHE BOOL "") set (BUILD_TESTING OFF CACHE BOOL "") set (USE_INTERMEDIATE_OBJECTS_TARGET OFF CACHE BOOL "") -if (CRYPTOPP_CUSTOM OR NOT RAIBLOCKS_SIMD_OPTIMIZATIONS) +if (CRYPTOPP_CUSTOM OR NOT (NANO_SIMD_OPTIMIZATIONS OR RAIBLOCKS_SIMD_OPTIMIZATIONS)) set (CRYPTOPP_LIBRARY cryptopp) add_library (cryptopp cryptopp/algparam.cpp @@ -227,12 +227,12 @@ add_library (blake2 target_compile_definitions(blake2 PRIVATE -D__SSE2__) -add_subdirectory(rai/secure) -add_subdirectory(rai/lib) -add_subdirectory(rai/node) -add_subdirectory(rai/rai_node) +add_subdirectory(nano/secure) +add_subdirectory(nano/lib) +add_subdirectory(nano/node) +add_subdirectory(nano/nano_node) -if (RAIBLOCKS_TEST) +if (NANO_TEST OR RAIBLOCKS_TEST) if(WIN32) if(MSVC_VERSION) if(MSVC_VERSION GREATER_EQUAL 1910) @@ -252,11 +252,11 @@ if (RAIBLOCKS_TEST) set_target_properties(gtest PROPERTIES INTERFACE_INCLUDE_DIRECTORIES "${CMAKE_SOURCE_DIR}/gtest/include") - add_subdirectory(rai/core_test) - add_subdirectory(rai/slow_test) + add_subdirectory(nano/core_test) + add_subdirectory(nano/slow_test) endif () -if (RAIBLOCKS_GUI) +if (NANO_GUI OR RAIBLOCKS_GUI) if (WIN32) set (PLATFORM_QT_PACKAGES WinExtras) else () @@ -266,16 +266,16 @@ if (RAIBLOCKS_GUI) find_package (Qt5 COMPONENTS Core Gui Widgets Test ${PLATFORM_QT_PACKAGES}) add_library (qt - rai/qt/qt.cpp - rai/qt/qt.hpp) + nano/qt/qt.cpp + nano/qt/qt.hpp) target_link_libraries(qt - secure rai_lib node libminiupnpc-static Qt5::Gui Qt5::Widgets) + secure nano_lib node libminiupnpc-static Qt5::Gui Qt5::Widgets) target_compile_definitions(qt PRIVATE - -DRAIBLOCKS_VERSION_MAJOR=${CPACK_PACKAGE_VERSION_MAJOR} - -DRAIBLOCKS_VERSION_MINOR=${CPACK_PACKAGE_VERSION_MINOR}) + -DNANO_VERSION_MAJOR=${CPACK_PACKAGE_VERSION_MAJOR} + -DNANO_VERSION_MINOR=${CPACK_PACKAGE_VERSION_MINOR}) if (WIN32) set (PLATFORM_GUI_TARGET_PROPERTIES WIN32) @@ -284,13 +284,13 @@ if (RAIBLOCKS_GUI) endif () if (${CMAKE_SYSTEM_NAME} MATCHES "Darwin") - set (PLATFORM_WALLET_SOURCE rai/rai_wallet/plat/default/icon.cpp) + set (PLATFORM_WALLET_SOURCE nano/nano_wallet/plat/default/icon.cpp) elseif (${CMAKE_SYSTEM_NAME} MATCHES "Windows") - set (PLATFORM_WALLET_SOURCE rai/rai_wallet/plat/windows/icon.cpp RaiBlocks.rc) + set (PLATFORM_WALLET_SOURCE nano/nano_wallet/plat/windows/icon.cpp Nano.rc) elseif (${CMAKE_SYSTEM_NAME} MATCHES "Linux") - set (PLATFORM_WALLET_SOURCE rai/rai_wallet/plat/default/icon.cpp) + set (PLATFORM_WALLET_SOURCE nano/nano_wallet/plat/default/icon.cpp) elseif (${CMAKE_SYSTEM_NAME} MATCHES "FreeBSD") - set (PLATFORM_WALLET_SOURCE rai/rai_wallet/plat/default/icon.cpp) + set (PLATFORM_WALLET_SOURCE nano/nano_wallet/plat/default/icon.cpp) else () error ("Unknown platform: ${CMAKE_SYSTEM_NAME}") endif () @@ -299,8 +299,8 @@ if (RAIBLOCKS_GUI) add_executable (nano_wallet ${PLATFORM_GUI_TARGET_PROPERTIES} ${PLATFORM_WALLET_SOURCE} - rai/rai_wallet/entry.cpp - rai/rai_wallet/icon.hpp + nano/nano_wallet/entry.cpp + nano/nano_wallet/icon.hpp ${RES}) target_link_libraries (nano_wallet @@ -312,16 +312,16 @@ if (RAIBLOCKS_GUI) endif() add_executable (qt_system - rai/qt_system/entry.cpp) + nano/qt_system/entry.cpp) target_link_libraries (qt_system qt node Qt5::Gui Qt5::Widgets) set_target_properties (qt nano_wallet qt_system PROPERTIES COMPILE_FLAGS "-DQT_NO_KEYWORDS -DBOOST_ASIO_HAS_STD_ARRAY=1") - if (RAIBLOCKS_TEST) + if (NANO_TEST OR RAIBLOCKS_TEST) add_executable (qt_test - rai/qt_test/entry.cpp - rai/qt_test/qt.cpp) + nano/qt_test/entry.cpp + nano/qt_test/qt.cpp) target_link_libraries(qt_test gtest gtest_main qt Qt5::Test) @@ -338,7 +338,7 @@ if (RAIBLOCKS_GUI) install (DIRECTORY ${Qt5_DIR}/../../QtTest.framework DESTINATION Nano.app/Contents/Frameworks) install (DIRECTORY ${Qt5_DIR}/../../QtWidgets.framework DESTINATION Nano.app/Contents/Frameworks) install (FILES "${Qt5_DIR}/../../../plugins/platforms/libqcocoa.dylib" DESTINATION Nano.app/Contents/PlugIns/platforms) - install (FILES RaiBlocks.icns DESTINATION Nano.app/Contents/Resources) + install (FILES Nano.icns DESTINATION Nano.app/Contents/Resources) elseif (WIN32) if ("${CMAKE_SIZEOF_VOID_P}" EQUAL "8") set (WIN_REDIST vc_redist.x64.exe) @@ -346,7 +346,7 @@ if (RAIBLOCKS_GUI) set (WIN_REDIST vc_redist.x86.exe) endif () set (CPACK_NSIS_EXTRA_INSTALL_COMMANDS "ExecWait '\\\"$INSTDIR\\\\${WIN_REDIST}\\\" /quiet /norestart'") - set (CPACK_NSIS_MUI_ICON ${CMAKE_SOURCE_DIR}/RaiBlocks.ico) + set (CPACK_NSIS_MUI_ICON ${CMAKE_SOURCE_DIR}/Nano.ico) set (CPACK_NSIS_DISPLAY_NAME "Nano") set (CPACK_PACKAGE_NAME "Nano_Installer") set (CPACK_NSIS_PACKAGE_NAME "Nano ${CPACK_PACKAGE_VERSION_MAJOR}.${CPACK_PACKAGE_VERSION_MINOR}.${CPACK_PACKAGE_VERSION_PATCH}") diff --git a/Info.plist b/Info.plist index d9941d9c..c5ca4049 100644 --- a/Info.plist +++ b/Info.plist @@ -13,9 +13,9 @@ CFBundleInfoDictionaryVersion 6.0 CFBundleIconFile - RaiBlocks.icns + Nano.icns CFBundleIdentifier - net.raiblocks.rai_wallet + org.nano.nano_wallet NSRequiresAquaSystemAppearance diff --git a/RaiBlocks.icns b/Nano.icns similarity index 100% rename from RaiBlocks.icns rename to Nano.icns diff --git a/RaiBlocks.ico b/Nano.ico similarity index 100% rename from RaiBlocks.ico rename to Nano.ico diff --git a/Nano.rc b/Nano.rc new file mode 100644 index 00000000..d4a9c876 --- /dev/null +++ b/Nano.rc @@ -0,0 +1 @@ +1 ICON "Nano.ico" \ No newline at end of file diff --git a/README.md b/README.md index 355e8c4c..ad174b5d 100644 --- a/README.md +++ b/README.md @@ -43,7 +43,7 @@ For more information, see [Nano.org](https://nano.org/) or read the [whitepaper] * [Reddit](https://reddit.com/r/nanocurrency) * [Medium](https://medium.com/nanocurrency) * [Twitter](https://twitter.com/nano) -* [Forum](https://forum.raiblocks.net/) +* [Forum](https://forum.nano.org/) * [GitHub wiki](https://github.com/nanocurrency/raiblocks/wiki) ### Want to Contribute? diff --git a/RaiBlocks.rc b/RaiBlocks.rc deleted file mode 100644 index f513adb6..00000000 --- a/RaiBlocks.rc +++ /dev/null @@ -1 +0,0 @@ -1 ICON "RaiBlocks.ico" \ No newline at end of file diff --git a/appveyor.yml b/appveyor.yml index 6cfa2ce1..a1b50a16 100644 --- a/appveyor.yml +++ b/appveyor.yml @@ -8,8 +8,8 @@ configuration: Release platform: x64 environment: matrix: - - network: rai_live_network - - network: rai_beta_network + - network: nano_live_network + - network: nano_beta_network clone_folder: C:\projects\myproject install: - cmd: >- @@ -17,7 +17,7 @@ install: git submodule update --init --recursive - cmake -DRAIBLOCKS_GUI=ON -DACTIVE_NETWORK=%NETWORK% -DQt5_DIR="C:\Qt\5.9\msvc2017_64\lib\cmake\Qt5" -DRAIBLOCKS_SIMD_OPTIMIZATIONS=TRUE -DBoost_COMPILER="-vc141" -DBOOST_ROOT="C:/Libraries/boost_1_66_0" -DBOOST_LIBRARYDIR="C:/Libraries/boost_1_66_0/lib64-msvc-14.1" -G "Visual Studio 15 2017 Win64" -DIPHLPAPI_LIBRARY="C:/Program Files (x86)/Windows Kits/10/Lib/10.0.14393.0/um/x64/iphlpapi.lib" -DWINSOCK2_LIBRARY="C:/Program Files (x86)/Windows Kits/10/Lib/10.0.14393.0/um/x64/WS2_32.lib" -DGIT_COMMIT=%GIT_COMMIT% + cmake -DNANO_GUI=ON -DACTIVE_NETWORK=%NETWORK% -DQt5_DIR="C:\Qt\5.9\msvc2017_64\lib\cmake\Qt5" -DNANO_SIMD_OPTIMIZATIONS=TRUE -DBoost_COMPILER="-vc141" -DBOOST_ROOT="C:/Libraries/boost_1_66_0" -DBOOST_LIBRARYDIR="C:/Libraries/boost_1_66_0/lib64-msvc-14.1" -G "Visual Studio 15 2017 Win64" -DIPHLPAPI_LIBRARY="C:/Program Files (x86)/Windows Kits/10/Lib/10.0.14393.0/um/x64/iphlpapi.lib" -DWINSOCK2_LIBRARY="C:/Program Files (x86)/Windows Kits/10/Lib/10.0.14393.0/um/x64/WS2_32.lib" -DGIT_COMMIT=%GIT_COMMIT% diff --git a/ci/build-gitlab.sh b/ci/build-gitlab.sh index ec3f3ba0..e439c6df 100755 --- a/ci/build-gitlab.sh +++ b/ci/build-gitlab.sh @@ -6,7 +6,7 @@ DISTRO_CFG="" if [[ "$OSTYPE" == "linux-gnu" ]]; then CPACK_TYPE="TBZ2" distro=$(lsb_release -i -c -s|tr '\n' '_') - DISTRO_CFG="-DRAIBLOCKS_DISTRO_NAME=${distro}" + DISTRO_CFG="-DNANO_DISTRO_NAME=${distro}" elif [[ "$OSTYPE" == "darwin"* ]]; then CPACK_TYPE="DragNDrop" elif [[ "$OSTYPE" == "cygwin" ]]; then @@ -17,13 +17,13 @@ elif [[ "$OSTYPE" == "win32" ]]; then CPACK_TYPE="NSIS" elif [[ "$OSTYPE" == "freebsd"* ]]; then CPACK_TYPE="TBZ2" - DISTRO_CFG="-DRAIBLOCKS_DISTRO_NAME='freebsd'" + DISTRO_CFG="-DNANO_DISTRO_NAME='freebsd'" else CPACK_TYPE="TBZ2" fi if [[ ${SIMD} -eq 1 ]]; then - SIMD_CFG="-DRAIBLOCKS_SIMD_OPTIMIZATIONS=ON" + SIMD_CFG="-DNANO_SIMD_OPTIMIZATIONS=ON" CRYPTOPP_CFG="" echo SIMD and other optimizations enabled echo local CPU: @@ -34,11 +34,11 @@ else fi if [[ ${ASAN_INT} -eq 1 ]]; then - SANITIZERS="-DRAIBLOCKS_ASAN_INT=ON" + SANITIZERS="-DNANO_ASAN_INT=ON" elif [[ ${ASAN} -eq 1 ]]; then - SANITIZERS="-DRAIBLOCKS_ASAN=ON" + SANITIZERS="-DNANO_ASAN=ON" elif [[ ${TSAN} -eq 1 ]]; then - SANITIZERS="-DRAIBLOCKS_TSAN=ON" + SANITIZERS="-DNANO_TSAN=ON" else SANITIZERS="" fi @@ -55,9 +55,9 @@ if [[ ${FLAVOR-_} == "_" ]]; then fi if [[ "${BETA}" -eq 1 ]]; then - NETWORK_CFG="-DACTIVE_NETWORK=rai_beta_network" + NETWORK_CFG="-DACTIVE_NETWORK=nano_beta_network" else - NETWORK_CFG="-DACTIVE_NETWORK=rai_live_network" + NETWORK_CFG="-DACTIVE_NETWORK=nano_live_network" fi set -o nounset @@ -68,7 +68,7 @@ run_build() { mkdir ${build_dir} cd ${build_dir} cmake -GNinja \ - -DRAIBLOCKS_GUI=ON \ + -DNANO_GUI=ON \ -DCMAKE_BUILD_TYPE=Release \ -DCMAKE_VERBOSE_MAKEFILE=ON \ -DCMAKE_INSTALL_PREFIX="../install" \ diff --git a/ci/build-travis.sh b/ci/build-travis.sh index 5d07bd16..b4fe76f5 100755 --- a/ci/build-travis.sh +++ b/ci/build-travis.sh @@ -12,20 +12,20 @@ mkdir build pushd build if [[ ${ASAN_INT-0} -eq 1 ]]; then - SANITIZERS="-DRAIBLOCKS_ASAN_INT=ON" + SANITIZERS="-DNANO_ASAN_INT=ON" elif [[ ${ASAN-0} -eq 1 ]]; then - SANITIZERS="-DRAIBLOCKS_ASAN=ON" + SANITIZERS="-DNANO_ASAN=ON" elif [[ ${TSAN-0} -eq 1 ]]; then - SANITIZERS="-DRAIBLOCKS_TSAN=ON" + SANITIZERS="-DNANO_TSAN=ON" else SANITIZERS="" fi cmake \ -G'Unix Makefiles' \ - -DACTIVE_NETWORK=rai_test_network \ - -DRAIBLOCKS_TEST=ON \ - -DRAIBLOCKS_GUI=ON \ + -DACTIVE_NETWORK=nano_test_network \ + -DNANO_TEST=ON \ + -DNANO_GUI=ON \ -DCMAKE_BUILD_TYPE=Debug \ -DCMAKE_VERBOSE_MAKEFILE=ON \ -DBOOST_ROOT=/usr/local \ @@ -46,6 +46,6 @@ popd pushd load-tester cargo build --release popd -cp ./load-tester/target/release/raiblocks-load-tester ./build/load_test +cp ./load-tester/target/release/nano-load-tester ./build/load_test ./ci/test.sh ./build diff --git a/ci/clang-format-all.sh b/ci/clang-format-all.sh index 635681a4..17661f19 100755 --- a/ci/clang-format-all.sh +++ b/ci/clang-format-all.sh @@ -5,4 +5,4 @@ set -e REPO_ROOT=$(git rev-parse --show-toplevel) cd "${REPO_ROOT}" ./ci/update-clang-format -find rai -iname '*.h' -o -iname '*.hpp' -o -iname '*.cpp' | xargs clang-format -i +find nano -iname '*.h' -o -iname '*.hpp' -o -iname '*.cpp' | xargs clang-format -i diff --git a/ci/test.sh b/ci/test.sh index cb167f71..ebcc01db 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -68,7 +68,7 @@ run_tests() { xvfb_run_ ./qt_test qt_test_res=${?} - ${TIMEOUT_CMD} ${TIMEOUT_TIME_ARG} ${TIMEOUT_SEC-${TIMEOUT_DEFAULT}} ./load_test ./rai_node -s 150 + ${TIMEOUT_CMD} ${TIMEOUT_TIME_ARG} ${TIMEOUT_SEC-${TIMEOUT_DEFAULT}} ./load_test ./nano_node -s 150 load_test_res=${?} echo "Core Test return code: ${core_test_res}" diff --git a/docker/ci/build.sh b/docker/ci/build.sh index e687ec77..bff9148a 100755 --- a/docker/ci/build.sh +++ b/docker/ci/build.sh @@ -1,5 +1,5 @@ #!/bin/bash REPO_ROOT=`git rev-parse --show-toplevel` pushd $REPO_ROOT -docker build -f docker/ci/Dockerfile -t raiblocks-ci:latest . +docker build -f docker/ci/Dockerfile -t nano-ci:latest . popd diff --git a/docker/node/Dockerfile b/docker/node/Dockerfile index 81fe522d..13995c11 100644 --- a/docker/node/Dockerfile +++ b/docker/node/Dockerfile @@ -13,15 +13,15 @@ ADD ./ /tmp/src RUN mkdir /tmp/build && \ cd /tmp/build && \ - cmake /tmp/src -DBOOST_ROOT=${BOOST_ROOT} -DACTIVE_NETWORK=rai_${NETWORK}_network && \ - make rai_node && \ + cmake /tmp/src -DBOOST_ROOT=${BOOST_ROOT} -DACTIVE_NETWORK=nano_${NETWORK}_network && \ + make nano_node && \ cd .. && \ echo ${NETWORK} > /etc/nano-network FROM ubuntu:16.04 -COPY --from=0 /tmp/build/rai_node /usr/bin +COPY --from=0 /tmp/build/nano_node /usr/bin COPY --from=0 /etc/nano-network /etc COPY docker/node/entry.sh /entry.sh -COPY docker/node/config /usr/share/raiblocks/config +COPY docker/node/config /usr/share/nano/config RUN chmod +x /entry.sh CMD ["/bin/bash", "/entry.sh"] diff --git a/docker/node/build.sh b/docker/node/build.sh index 7885e5eb..eac538e8 100755 --- a/docker/node/build.sh +++ b/docker/node/build.sh @@ -38,5 +38,5 @@ esac REPO_ROOT=`git rev-parse --show-toplevel` COMMIT_SHA=`git rev-parse --short HEAD` pushd $REPO_ROOT -docker build --build-arg NETWORK="${network}" -f docker/node/Dockerfile -t raiblocks-node${network_tag}:latest . +docker build --build-arg NETWORK="${network}" -f docker/node/Dockerfile -t nano-node${network_tag}:latest . popd diff --git a/docker/node/entry.sh b/docker/node/entry.sh index 1db90e29..1a44e0b9 100644 --- a/docker/node/entry.sh +++ b/docker/node/entry.sh @@ -20,12 +20,12 @@ case "${network}" in ;; esac -nanodir="${HOME}/RaiBlocks${dirSuffix}" +nanodir="${HOME}/Nano${dirSuffix}" dbFile="${nanodir}/data.ldb" mkdir -p "${nanodir}" if [ ! -f "${nanodir}/config.json" ]; then echo "Config File not found, adding default." - cp "/usr/share/raiblocks/config/${network}.json" "${nanodir}/config.json" + cp "/usr/share/nano/config/${network}.json" "${nanodir}/config.json" fi pid='' @@ -48,7 +48,7 @@ while true; do fi done - rai_node --vacuum + nano_node --vacuum fi fi @@ -59,7 +59,7 @@ while true; do fi if [ -z "${pid}" ]; then - rai_node --daemon & + nano_node --daemon & pid="$!" fi done diff --git a/doxygen.config b/doxygen.config index 3ece9724..1801f583 100644 --- a/doxygen.config +++ b/doxygen.config @@ -791,7 +791,7 @@ WARN_LOGFILE = # spaces. See also FILE_PATTERNS and EXTENSION_MAPPING # Note: If this tag is empty the current directory is searched. -INPUT = rai +INPUT = nano # This tag can be used to specify the character encoding of the source files # that doxygen parses. Internally doxygen uses the UTF-8 encoding. Doxygen uses diff --git a/load-tester/Cargo.lock b/load-tester/Cargo.lock index 1073cd52..249c05f0 100644 --- a/load-tester/Cargo.lock +++ b/load-tester/Cargo.lock @@ -380,7 +380,7 @@ version = "0.3.15" source = "registry+https://github.com/rust-lang/crates.io-index" [[package]] -name = "raiblocks-load-tester" +name = "nano-load-tester" version = "0.1.0" dependencies = [ "clap 2.29.2 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/load-tester/Cargo.toml b/load-tester/Cargo.toml index a4351537..7cf731ed 100644 --- a/load-tester/Cargo.toml +++ b/load-tester/Cargo.toml @@ -1,5 +1,5 @@ [package] -name = "raiblocks-load-tester" +name = "nano-load-tester" version = "0.1.0" [dependencies] diff --git a/load-tester/src/launch_node.rs b/load-tester/src/launch_node.rs index a07da1a6..8d4ab302 100644 --- a/load-tester/src/launch_node.rs +++ b/load-tester/src/launch_node.rs @@ -22,18 +22,18 @@ const RPC_PORT_START: u64 = 55000; const PEERING_PORT_START: u64 = 54000; pub fn launch_node( - rai_node: &Path, + nano_node: &Path, tmp_dir: &Path, handle: Handle, i: u64, ) -> Result<(Child, RpcClient)> { - let data_dir = tmp_dir.join(format!("RaiBlocks_load_test_{}", i)); + let data_dir = tmp_dir.join(format!("Nano_load_test_{}", i)); match fs::create_dir(&data_dir) { Ok(_) => {} Err(ref e) if e.kind() == io::ErrorKind::AlreadyExists => { let _ = fs::remove_file(data_dir.join("data.ldb")); } - r => r.chain_err(|| "failed to create rai_node data directory")?, + r => r.chain_err(|| "failed to create nano_node data directory")?, } let rpc_port = RPC_PORT_START + i; let peering_port = PEERING_PORT_START + i; @@ -97,12 +97,12 @@ pub fn launch_node( File::create(data_dir.join("config.json")).chain_err(|| "failed to create config.json")?; serde_json::to_writer_pretty(config_writer, &config) .chain_err(|| "failed to write config.json")?; - let child = Command::new(rai_node) + let child = Command::new(nano_node) .arg("--data_path") .arg(&data_dir) .arg("--daemon") .spawn_async(&handle) - .chain_err(|| "failed to spawn rai_node")?; + .chain_err(|| "failed to spawn nano_node")?; let rpc_client = RpcClient::new( handle, format!("http://[::1]:{}/", rpc_port).parse().unwrap(), @@ -119,7 +119,7 @@ pub fn connect_node( "action": "keepalive", "address": "::1", "port": PEERING_PORT_START + i, - })).then(|x| x.chain_err(|| "failed to call rai_node RPC")) + })).then(|x| x.chain_err(|| "failed to call nano_node RPC")) .map(|_| ()), ) as _ } diff --git a/load-tester/src/main.rs b/load-tester/src/main.rs index 0c3cc124..035ed433 100644 --- a/load-tester/src/main.rs +++ b/load-tester/src/main.rs @@ -428,7 +428,7 @@ fn run(params: Parameters) -> Result<()> { fn main() { env_logger::init(); - let matches = clap::App::new("raiblocks-load-tester") + let matches = clap::App::new("nano-load-tester") .version(env!("CARGO_PKG_VERSION")) .arg( Arg::with_name("node_count") @@ -442,13 +442,13 @@ fn main() { Arg::with_name("tmp_dir") .long("tmp-dir") .value_name("PATH") - .help("The path to a temporary directory for rai_node data"), + .help("The path to a temporary directory for nano_node data"), ) .arg( Arg::with_name("node_path") .value_name("PATH") .required(true) - .help("The path to the rai_node to test"), + .help("The path to the nano_node to test"), ) .arg( Arg::with_name("send_count") diff --git a/rai/core_test/CMakeLists.txt b/nano/core_test/CMakeLists.txt similarity index 80% rename from rai/core_test/CMakeLists.txt rename to nano/core_test/CMakeLists.txt index 39c4301c..c5ad3a48 100644 --- a/rai/core_test/CMakeLists.txt +++ b/nano/core_test/CMakeLists.txt @@ -24,6 +24,6 @@ add_executable (core_test target_compile_definitions(core_test PRIVATE - -DRAIBLOCKS_VERSION_MAJOR=${CPACK_PACKAGE_VERSION_MAJOR} - -DRAIBLOCKS_VERSION_MINOR=${CPACK_PACKAGE_VERSION_MINOR}) + -DNANO_VERSION_MAJOR=${CPACK_PACKAGE_VERSION_MAJOR} + -DNANO_VERSION_MINOR=${CPACK_PACKAGE_VERSION_MINOR}) target_link_libraries (core_test node secure gtest_main gtest libminiupnpc-static Boost::boost) diff --git a/rai/core_test/block.cpp b/nano/core_test/block.cpp similarity index 70% rename from rai/core_test/block.cpp rename to nano/core_test/block.cpp index ecc56788..98b2dda0 100644 --- a/rai/core_test/block.cpp +++ b/nano/core_test/block.cpp @@ -3,20 +3,20 @@ #include #include -#include +#include -#include -#include -#include +#include +#include +#include #include TEST (ed25519, signing) { - rai::uint256_union prv (0); - rai::uint256_union pub (rai::pub_key (prv)); - rai::uint256_union message (0); - rai::uint512_union signature; + nano::uint256_union prv (0); + nano::uint256_union pub (nano::pub_key (prv)); + nano::uint256_union message (0); + nano::uint512_union signature; ed25519_sign (message.bytes.data (), sizeof (message.bytes), prv.bytes.data (), pub.bytes.data (), signature.bytes.data ()); auto valid1 (ed25519_sign_open (message.bytes.data (), sizeof (message.bytes), pub.bytes.data (), signature.bytes.data ())); ASSERT_EQ (0, valid1); @@ -27,36 +27,36 @@ TEST (ed25519, signing) TEST (transaction_block, empty) { - rai::keypair key1; - rai::send_block block (0, 1, 13, key1.prv, key1.pub, 2); - rai::uint256_union hash (block.hash ()); - ASSERT_FALSE (rai::validate_message (key1.pub, hash, block.signature)); + nano::keypair key1; + nano::send_block block (0, 1, 13, key1.prv, key1.pub, 2); + nano::uint256_union hash (block.hash ()); + ASSERT_FALSE (nano::validate_message (key1.pub, hash, block.signature)); block.signature.bytes[32] ^= 0x1; - ASSERT_TRUE (rai::validate_message (key1.pub, hash, block.signature)); + ASSERT_TRUE (nano::validate_message (key1.pub, hash, block.signature)); } TEST (block, send_serialize) { - rai::send_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5); + nano::send_block block1 (0, 1, 2, nano::keypair ().prv, 4, 5); std::vector bytes; { - rai::vectorstream stream1 (bytes); + nano::vectorstream stream1 (bytes); block1.serialize (stream1); } auto data (bytes.data ()); auto size (bytes.size ()); ASSERT_NE (nullptr, data); ASSERT_NE (0, size); - rai::bufferstream stream2 (data, size); + nano::bufferstream stream2 (data, size); bool error (false); - rai::send_block block2 (error, stream2); + nano::send_block block2 (error, stream2); ASSERT_FALSE (error); ASSERT_EQ (block1, block2); } TEST (block, send_serialize_json) { - rai::send_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5); + nano::send_block block1 (0, 1, 2, nano::keypair ().prv, 4, 5); std::string string1; block1.serialize_json (string1); ASSERT_NE (0, string1.size ()); @@ -64,30 +64,30 @@ TEST (block, send_serialize_json) std::stringstream istream (string1); boost::property_tree::read_json (istream, tree1); bool error (false); - rai::send_block block2 (error, tree1); + nano::send_block block2 (error, tree1); ASSERT_FALSE (error); ASSERT_EQ (block1, block2); } TEST (block, receive_serialize) { - rai::receive_block block1 (0, 1, rai::keypair ().prv, 3, 4); - rai::keypair key1; + nano::receive_block block1 (0, 1, nano::keypair ().prv, 3, 4); + nano::keypair key1; std::vector bytes; { - rai::vectorstream stream1 (bytes); + nano::vectorstream stream1 (bytes); block1.serialize (stream1); } - rai::bufferstream stream2 (bytes.data (), bytes.size ()); + nano::bufferstream stream2 (bytes.data (), bytes.size ()); bool error (false); - rai::receive_block block2 (error, stream2); + nano::receive_block block2 (error, stream2); ASSERT_FALSE (error); ASSERT_EQ (block1, block2); } TEST (block, receive_serialize_json) { - rai::receive_block block1 (0, 1, rai::keypair ().prv, 3, 4); + nano::receive_block block1 (0, 1, nano::keypair ().prv, 3, 4); std::string string1; block1.serialize_json (string1); ASSERT_NE (0, string1.size ()); @@ -95,14 +95,14 @@ TEST (block, receive_serialize_json) std::stringstream istream (string1); boost::property_tree::read_json (istream, tree1); bool error (false); - rai::receive_block block2 (error, tree1); + nano::receive_block block2 (error, tree1); ASSERT_FALSE (error); ASSERT_EQ (block1, block2); } TEST (block, open_serialize_json) { - rai::open_block block1 (0, 1, 0, rai::keypair ().prv, 0, 0); + nano::open_block block1 (0, 1, 0, nano::keypair ().prv, 0, 0); std::string string1; block1.serialize_json (string1); ASSERT_NE (0, string1.size ()); @@ -110,14 +110,14 @@ TEST (block, open_serialize_json) std::stringstream istream (string1); boost::property_tree::read_json (istream, tree1); bool error (false); - rai::open_block block2 (error, tree1); + nano::open_block block2 (error, tree1); ASSERT_FALSE (error); ASSERT_EQ (block1, block2); } TEST (block, change_serialize_json) { - rai::change_block block1 (0, 1, rai::keypair ().prv, 3, 4); + nano::change_block block1 (0, 1, nano::keypair ().prv, 3, 4); std::string string1; block1.serialize_json (string1); ASSERT_NE (0, string1.size ()); @@ -125,17 +125,17 @@ TEST (block, change_serialize_json) std::stringstream istream (string1); boost::property_tree::read_json (istream, tree1); bool error (false); - rai::change_block block2 (error, tree1); + nano::change_block block2 (error, tree1); ASSERT_FALSE (error); ASSERT_EQ (block1, block2); } TEST (uint512_union, parse_zero) { - rai::uint512_union input (rai::uint512_t (0)); + nano::uint512_union input (nano::uint512_t (0)); std::string text; input.encode_hex (text); - rai::uint512_union output; + nano::uint512_union output; auto error (output.decode_hex (text)); ASSERT_FALSE (error); ASSERT_EQ (input, output); @@ -145,7 +145,7 @@ TEST (uint512_union, parse_zero) TEST (uint512_union, parse_zero_short) { std::string text ("0"); - rai::uint512_union output; + nano::uint512_union output; auto error (output.decode_hex (text)); ASSERT_FALSE (error); ASSERT_TRUE (output.number ().is_zero ()); @@ -153,10 +153,10 @@ TEST (uint512_union, parse_zero_short) TEST (uint512_union, parse_one) { - rai::uint512_union input (rai::uint512_t (1)); + nano::uint512_union input (nano::uint512_t (1)); std::string text; input.encode_hex (text); - rai::uint512_union output; + nano::uint512_union output; auto error (output.decode_hex (text)); ASSERT_FALSE (error); ASSERT_EQ (input, output); @@ -165,148 +165,148 @@ TEST (uint512_union, parse_one) TEST (uint512_union, parse_error_symbol) { - rai::uint512_union input (rai::uint512_t (1000)); + nano::uint512_union input (nano::uint512_t (1000)); std::string text; input.encode_hex (text); text[5] = '!'; - rai::uint512_union output; + nano::uint512_union output; auto error (output.decode_hex (text)); ASSERT_TRUE (error); } TEST (uint512_union, max) { - rai::uint512_union input (std::numeric_limits::max ()); + nano::uint512_union input (std::numeric_limits::max ()); std::string text; input.encode_hex (text); - rai::uint512_union output; + nano::uint512_union output; auto error (output.decode_hex (text)); ASSERT_FALSE (error); ASSERT_EQ (input, output); - ASSERT_EQ (rai::uint512_t ("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), output.number ()); + ASSERT_EQ (nano::uint512_t ("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), output.number ()); } TEST (uint512_union, parse_error_overflow) { - rai::uint512_union input (std::numeric_limits::max ()); + nano::uint512_union input (std::numeric_limits::max ()); std::string text; input.encode_hex (text); text.push_back (0); - rai::uint512_union output; + nano::uint512_union output; auto error (output.decode_hex (text)); ASSERT_TRUE (error); } TEST (send_block, deserialize) { - rai::send_block block1 (0, 1, 2, rai::keypair ().prv, 4, 5); + nano::send_block block1 (0, 1, 2, nano::keypair ().prv, 4, 5); ASSERT_EQ (block1.hash (), block1.hash ()); std::vector bytes; { - rai::vectorstream stream1 (bytes); + nano::vectorstream stream1 (bytes); block1.serialize (stream1); } - ASSERT_EQ (rai::send_block::size, bytes.size ()); - rai::bufferstream stream2 (bytes.data (), bytes.size ()); + ASSERT_EQ (nano::send_block::size, bytes.size ()); + nano::bufferstream stream2 (bytes.data (), bytes.size ()); bool error (false); - rai::send_block block2 (error, stream2); + nano::send_block block2 (error, stream2); ASSERT_FALSE (error); ASSERT_EQ (block1, block2); } TEST (receive_block, deserialize) { - rai::receive_block block1 (0, 1, rai::keypair ().prv, 3, 4); + nano::receive_block block1 (0, 1, nano::keypair ().prv, 3, 4); ASSERT_EQ (block1.hash (), block1.hash ()); block1.hashables.previous = 2; block1.hashables.source = 4; std::vector bytes; { - rai::vectorstream stream1 (bytes); + nano::vectorstream stream1 (bytes); block1.serialize (stream1); } - ASSERT_EQ (rai::receive_block::size, bytes.size ()); - rai::bufferstream stream2 (bytes.data (), bytes.size ()); + ASSERT_EQ (nano::receive_block::size, bytes.size ()); + nano::bufferstream stream2 (bytes.data (), bytes.size ()); bool error (false); - rai::receive_block block2 (error, stream2); + nano::receive_block block2 (error, stream2); ASSERT_FALSE (error); ASSERT_EQ (block1, block2); } TEST (open_block, deserialize) { - rai::open_block block1 (0, 1, 0, rai::keypair ().prv, 0, 0); + nano::open_block block1 (0, 1, 0, nano::keypair ().prv, 0, 0); ASSERT_EQ (block1.hash (), block1.hash ()); std::vector bytes; { - rai::vectorstream stream (bytes); + nano::vectorstream stream (bytes); block1.serialize (stream); } - ASSERT_EQ (rai::open_block::size, bytes.size ()); - rai::bufferstream stream (bytes.data (), bytes.size ()); + ASSERT_EQ (nano::open_block::size, bytes.size ()); + nano::bufferstream stream (bytes.data (), bytes.size ()); bool error (false); - rai::open_block block2 (error, stream); + nano::open_block block2 (error, stream); ASSERT_FALSE (error); ASSERT_EQ (block1, block2); } TEST (change_block, deserialize) { - rai::change_block block1 (1, 2, rai::keypair ().prv, 4, 5); + nano::change_block block1 (1, 2, nano::keypair ().prv, 4, 5); ASSERT_EQ (block1.hash (), block1.hash ()); std::vector bytes; { - rai::vectorstream stream1 (bytes); + nano::vectorstream stream1 (bytes); block1.serialize (stream1); } - ASSERT_EQ (rai::change_block::size, bytes.size ()); + ASSERT_EQ (nano::change_block::size, bytes.size ()); auto data (bytes.data ()); auto size (bytes.size ()); ASSERT_NE (nullptr, data); ASSERT_NE (0, size); - rai::bufferstream stream2 (data, size); + nano::bufferstream stream2 (data, size); bool error (false); - rai::change_block block2 (error, stream2); + nano::change_block block2 (error, stream2); ASSERT_FALSE (error); ASSERT_EQ (block1, block2); } TEST (frontier_req, serialization) { - rai::frontier_req request1; + nano::frontier_req request1; request1.start = 1; request1.age = 2; request1.count = 3; std::vector bytes; { - rai::vectorstream stream (bytes); + nano::vectorstream stream (bytes); request1.serialize (stream); } auto error (false); - rai::bufferstream stream (bytes.data (), bytes.size ()); - rai::message_header header (error, stream); + nano::bufferstream stream (bytes.data (), bytes.size ()); + nano::message_header header (error, stream); ASSERT_FALSE (error); - rai::frontier_req request2 (error, stream, header); + nano::frontier_req request2 (error, stream, header); ASSERT_FALSE (error); ASSERT_EQ (request1, request2); } TEST (block, publish_req_serialization) { - rai::keypair key1; - rai::keypair key2; - auto block (std::make_shared (0, key2.pub, 200, rai::keypair ().prv, 2, 3)); - rai::publish req (block); + nano::keypair key1; + nano::keypair key2; + auto block (std::make_shared (0, key2.pub, 200, nano::keypair ().prv, 2, 3)); + nano::publish req (block); std::vector bytes; { - rai::vectorstream stream (bytes); + nano::vectorstream stream (bytes); req.serialize (stream); } auto error (false); - rai::bufferstream stream2 (bytes.data (), bytes.size ()); - rai::message_header header (error, stream2); + nano::bufferstream stream2 (bytes.data (), bytes.size ()); + nano::message_header header (error, stream2); ASSERT_FALSE (error); - rai::publish req2 (error, stream2, header); + nano::publish req2 (error, stream2, header); ASSERT_FALSE (error); ASSERT_EQ (req, req2); ASSERT_EQ (*req.block, *req2.block); @@ -314,19 +314,19 @@ TEST (block, publish_req_serialization) TEST (block, confirm_req_serialization) { - rai::keypair key1; - rai::keypair key2; - auto block (std::make_shared (0, key2.pub, 200, rai::keypair ().prv, 2, 3)); - rai::confirm_req req (block); + nano::keypair key1; + nano::keypair key2; + auto block (std::make_shared (0, key2.pub, 200, nano::keypair ().prv, 2, 3)); + nano::confirm_req req (block); std::vector bytes; { - rai::vectorstream stream (bytes); + nano::vectorstream stream (bytes); req.serialize (stream); } auto error (false); - rai::bufferstream stream2 (bytes.data (), bytes.size ()); - rai::message_header header (error, stream2); - rai::confirm_req req2 (error, stream2, header); + nano::bufferstream stream2 (bytes.data (), bytes.size ()); + nano::message_header header (error, stream2); + nano::confirm_req req2 (error, stream2, header); ASSERT_FALSE (error); ASSERT_EQ (req, req2); ASSERT_EQ (*req.block, *req2.block); @@ -334,24 +334,24 @@ TEST (block, confirm_req_serialization) TEST (state_block, serialization) { - rai::keypair key1; - rai::keypair key2; - rai::state_block block1 (key1.pub, 1, key2.pub, 2, 4, key1.prv, key1.pub, 5); + nano::keypair key1; + nano::keypair key2; + nano::state_block block1 (key1.pub, 1, key2.pub, 2, 4, key1.prv, key1.pub, 5); ASSERT_EQ (key1.pub, block1.hashables.account); - ASSERT_EQ (rai::block_hash (1), block1.previous ()); + ASSERT_EQ (nano::block_hash (1), block1.previous ()); ASSERT_EQ (key2.pub, block1.hashables.representative); - ASSERT_EQ (rai::amount (2), block1.hashables.balance); - ASSERT_EQ (rai::uint256_union (4), block1.hashables.link); + ASSERT_EQ (nano::amount (2), block1.hashables.balance); + ASSERT_EQ (nano::uint256_union (4), block1.hashables.link); std::vector bytes; { - rai::vectorstream stream (bytes); + nano::vectorstream stream (bytes); block1.serialize (stream); } ASSERT_EQ (0x5, bytes[215]); // Ensure work is serialized big-endian - ASSERT_EQ (rai::state_block::size, bytes.size ()); + ASSERT_EQ (nano::state_block::size, bytes.size ()); bool error1 (false); - rai::bufferstream stream (bytes.data (), bytes.size ()); - rai::state_block block2 (error1, stream); + nano::bufferstream stream (bytes.data (), bytes.size ()); + nano::state_block block2 (error1, stream); ASSERT_FALSE (error1); ASSERT_EQ (block1, block2); block2.hashables.account.clear (); @@ -361,7 +361,7 @@ TEST (state_block, serialization) block2.hashables.link.clear (); block2.signature.clear (); block2.work = 0; - rai::bufferstream stream2 (bytes.data (), bytes.size ()); + nano::bufferstream stream2 (bytes.data (), bytes.size ()); ASSERT_FALSE (block2.deserialize (stream2)); ASSERT_EQ (block1, block2); std::string json; @@ -370,7 +370,7 @@ TEST (state_block, serialization) boost::property_tree::ptree tree; boost::property_tree::read_json (body, tree); bool error2 (false); - rai::state_block block3 (error2, tree); + nano::state_block block3 (error2, tree); ASSERT_FALSE (error2); ASSERT_EQ (block1, block3); block3.hashables.account.clear (); @@ -386,8 +386,8 @@ TEST (state_block, serialization) TEST (state_block, hashing) { - rai::keypair key; - rai::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0); + nano::keypair key; + nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0); auto hash (block.hash ()); block.hashables.account.bytes[0] ^= 0x1; ASSERT_NE (hash, block.hash ()); @@ -413,20 +413,20 @@ TEST (state_block, hashing) TEST (block_uniquer, null) { - rai::block_uniquer uniquer; + nano::block_uniquer uniquer; ASSERT_EQ (nullptr, uniquer.unique (nullptr)); } TEST (block_uniquer, single) { - rai::keypair key; - auto block1 (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0)); - auto block2 (std::make_shared (*block1)); + nano::keypair key; + auto block1 (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0)); + auto block2 (std::make_shared (*block1)); ASSERT_NE (block1, block2); ASSERT_EQ (*block1, *block2); - std::weak_ptr block3 (block2); + std::weak_ptr block3 (block2); ASSERT_NE (nullptr, block3.lock ()); - rai::block_uniquer uniquer; + nano::block_uniquer uniquer; auto block4 (uniquer.unique (block1)); ASSERT_EQ (block1, block4); auto block5 (uniquer.unique (block2)); @@ -437,10 +437,10 @@ TEST (block_uniquer, single) TEST (block_uniquer, cleanup) { - rai::keypair key; - auto block1 (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0)); - auto block2 (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 1)); - rai::block_uniquer uniquer; + nano::keypair key; + auto block1 (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0)); + auto block2 (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 1)); + nano::block_uniquer uniquer; auto block3 (uniquer.unique (block1)); auto block4 (uniquer.unique (block2)); block2.reset (); @@ -457,20 +457,20 @@ TEST (block_uniquer, cleanup) TEST (block_builder, zeroed_state_block) { std::error_code ec; - rai::block_builder builder; - rai::keypair key; + nano::block_builder builder; + nano::keypair key; // Make sure manually- and builder constructed all-zero blocks have equal hashes, and check signature. - auto zero_block_manual (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0)); + auto zero_block_manual (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0)); auto zero_block_build = builder.state ().zero ().sign (key.prv, key.pub).build (); ASSERT_TRUE (zero_block_manual->hash () == zero_block_build->hash ()); - ASSERT_FALSE (rai::validate_message (key.pub, zero_block_build->hash (), zero_block_build->signature)); + ASSERT_FALSE (nano::validate_message (key.pub, zero_block_build->hash (), zero_block_build->signature)); } TEST (block_builder, state) { // Test against a random hash from the live network std::error_code ec; - rai::block_builder builder; + nano::block_builder builder; auto block = builder .state () .account_address ("xrb_15nhh1kzw3x8ohez6s75wy3jr6dqgq65oaede1fzk5hqxk4j8ehz7iqtb3to") @@ -486,7 +486,7 @@ TEST (block_builder, state_missing_rep) { // Test against a random hash from the live network std::error_code ec; - rai::block_builder builder; + nano::block_builder builder; auto block = builder .state () .account_address ("xrb_15nhh1kzw3x8ohez6s75wy3jr6dqgq65oaede1fzk5hqxk4j8ehz7iqtb3to") @@ -502,11 +502,11 @@ TEST (block_builder, state_missing_rep) TEST (block_builder, state_equality) { std::error_code ec; - rai::block_builder builder; + nano::block_builder builder; // With constructor - rai::keypair key1, key2; - rai::state_block block1 (key1.pub, 1, key2.pub, 2, 4, key1.prv, key1.pub, 5); + nano::keypair key1, key2; + nano::state_block block1 (key1.pub, 1, key2.pub, 2, 4, key1.prv, key1.pub, 5); // With builder auto block2 = builder @@ -528,7 +528,7 @@ TEST (block_builder, state_equality) TEST (block_builder, state_errors) { std::error_code ec; - rai::block_builder builder; + nano::block_builder builder; // Make sure we assert when building a block without an std::error_code EXPECT_DEATH (builder @@ -549,7 +549,7 @@ TEST (block_builder, open) { // Test built block's hash against the Genesis open block from the live network std::error_code ec; - rai::block_builder builder; + nano::block_builder builder; auto block = builder .open () .account_address ("xrb_3t6k35gi95xu6tergt6p69ck76ogmitsa8mnijtpxm9fkcm736xtoncuohr3") @@ -562,11 +562,11 @@ TEST (block_builder, open) TEST (block_builder, open_equality) { std::error_code ec; - rai::block_builder builder; + nano::block_builder builder; // With constructor - rai::keypair key1, key2; - rai::open_block block1 (1, key1.pub, key2.pub, key1.prv, key1.pub, 5); + nano::keypair key1, key2; + nano::open_block block1 (1, key1.pub, key2.pub, key1.prv, key1.pub, 5); // With builder auto block2 = builder @@ -586,7 +586,7 @@ TEST (block_builder, open_equality) TEST (block_builder, change) { std::error_code ec; - rai::block_builder builder; + nano::block_builder builder; auto block = builder .change () .representative_address ("xrb_3rropjiqfxpmrrkooej4qtmm1pueu36f9ghinpho4esfdor8785a455d16nf") @@ -598,11 +598,11 @@ TEST (block_builder, change) TEST (block_builder, change_equality) { std::error_code ec; - rai::block_builder builder; + nano::block_builder builder; // With constructor - rai::keypair key1, key2; - rai::change_block block1 (1, key1.pub, key1.prv, key1.pub, 5); + nano::keypair key1, key2; + nano::change_block block1 (1, key1.pub, key1.prv, key1.pub, 5); // With builder auto block2 = builder @@ -621,7 +621,7 @@ TEST (block_builder, change_equality) TEST (block_builder, send) { std::error_code ec; - rai::block_builder builder; + nano::block_builder builder; auto block = builder .send () .destination_address ("xrb_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb") @@ -634,11 +634,11 @@ TEST (block_builder, send) TEST (block_builder, send_equality) { std::error_code ec; - rai::block_builder builder; + nano::block_builder builder; // With constructor - rai::keypair key1, key2; - rai::send_block block1 (1, key1.pub, 2, key1.prv, key1.pub, 5); + nano::keypair key1, key2; + nano::send_block block1 (1, key1.pub, 2, key1.prv, key1.pub, 5); // With builder auto block2 = builder @@ -658,11 +658,11 @@ TEST (block_builder, send_equality) TEST (block_builder, receive_equality) { std::error_code ec; - rai::block_builder builder; + nano::block_builder builder; // With constructor - rai::keypair key1; - rai::receive_block block1 (1, 2, key1.prv, key1.pub, 5); + nano::keypair key1; + nano::receive_block block1 (1, 2, key1.prv, key1.pub, 5); // With builder auto block2 = builder @@ -681,7 +681,7 @@ TEST (block_builder, receive_equality) TEST (block_builder, receive) { std::error_code ec; - rai::block_builder builder; + nano::block_builder builder; auto block = builder .receive () .previous_hex ("59660153194CAC5DAC08509D87970BF86F6AEA943025E2A7ED7460930594950E") diff --git a/rai/core_test/block_store.cpp b/nano/core_test/block_store.cpp similarity index 63% rename from rai/core_test/block_store.cpp rename to nano/core_test/block_store.cpp index 4622d2dc..e372a078 100644 --- a/rai/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -1,27 +1,27 @@ #include -#include -#include -#include -#include +#include +#include +#include +#include #include TEST (block_store, construction) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - auto now (rai::seconds_since_epoch ()); + auto now (nano::seconds_since_epoch ()); ASSERT_GT (now, 1408074640); } TEST (block_store, add_item) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::open_block block (0, 1, 0, rai::keypair ().prv, 0, 0); - rai::uint256_union hash1 (block.hash ()); + nano::open_block block (0, 1, 0, nano::keypair ().prv, 0, 0); + nano::uint256_union hash1 (block.hash ()); auto transaction (store.tx_begin (true)); auto latest1 (store.block_get (transaction, hash1)); ASSERT_EQ (nullptr, latest1); @@ -40,12 +40,12 @@ TEST (block_store, add_item) TEST (block_store, add_nonempty_block) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::keypair key1; - rai::open_block block (0, 1, 0, rai::keypair ().prv, 0, 0); - rai::uint256_union hash1 (block.hash ()); - block.signature = rai::sign_message (key1.prv, key1.pub, hash1); + nano::keypair key1; + nano::open_block block (0, 1, 0, nano::keypair ().prv, 0, 0); + nano::uint256_union hash1 (block.hash ()); + block.signature = nano::sign_message (key1.prv, key1.pub, hash1); auto transaction (store.tx_begin (true)); auto latest1 (store.block_get (transaction, hash1)); ASSERT_EQ (nullptr, latest1); @@ -58,19 +58,19 @@ TEST (block_store, add_nonempty_block) TEST (block_store, add_two_items) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::keypair key1; - rai::open_block block (0, 1, 1, rai::keypair ().prv, 0, 0); - rai::uint256_union hash1 (block.hash ()); - block.signature = rai::sign_message (key1.prv, key1.pub, hash1); + nano::keypair key1; + nano::open_block block (0, 1, 1, nano::keypair ().prv, 0, 0); + nano::uint256_union hash1 (block.hash ()); + block.signature = nano::sign_message (key1.prv, key1.pub, hash1); auto transaction (store.tx_begin (true)); auto latest1 (store.block_get (transaction, hash1)); ASSERT_EQ (nullptr, latest1); - rai::open_block block2 (0, 1, 3, rai::keypair ().prv, 0, 0); + nano::open_block block2 (0, 1, 3, nano::keypair ().prv, 0, 0); block2.hashables.account = 3; - rai::uint256_union hash2 (block2.hash ()); - block2.signature = rai::sign_message (key1.prv, key1.pub, hash2); + nano::uint256_union hash2 (block2.hash ()); + block2.signature = nano::sign_message (key1.prv, key1.pub, hash2); auto latest2 (store.block_get (transaction, hash2)); ASSERT_EQ (nullptr, latest2); store.block_put (transaction, hash1, block); @@ -87,15 +87,15 @@ TEST (block_store, add_two_items) TEST (block_store, add_receive) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::keypair key1; - rai::keypair key2; - rai::open_block block1 (0, 1, 0, rai::keypair ().prv, 0, 0); + nano::keypair key1; + nano::keypair key2; + nano::open_block block1 (0, 1, 0, nano::keypair ().prv, 0, 0); auto transaction (store.tx_begin (true)); store.block_put (transaction, block1.hash (), block1); - rai::receive_block block (block1.hash (), 1, rai::keypair ().prv, 2, 3); - rai::block_hash hash1 (block.hash ()); + nano::receive_block block (block1.hash (), 1, nano::keypair ().prv, 2, 3); + nano::block_hash hash1 (block.hash ()); auto latest1 (store.block_get (transaction, hash1)); ASSERT_EQ (nullptr, latest1); store.block_put (transaction, hash1, block); @@ -107,15 +107,15 @@ TEST (block_store, add_receive) TEST (block_store, add_pending) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::keypair key1; - rai::pending_key key2 (0, 0); - rai::pending_info pending1; + nano::keypair key1; + nano::pending_key key2 (0, 0); + nano::pending_info pending1; auto transaction (store.tx_begin (true)); ASSERT_TRUE (store.pending_get (transaction, key2, pending1)); store.pending_put (transaction, key2, pending1); - rai::pending_info pending2; + nano::pending_info pending2; ASSERT_FALSE (store.pending_get (transaction, key2, pending2)); ASSERT_EQ (pending1, pending2); store.pending_del (transaction, key2); @@ -125,20 +125,20 @@ TEST (block_store, add_pending) TEST (block_store, pending_iterator) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); auto transaction (store.tx_begin (true)); ASSERT_EQ (store.pending_end (), store.pending_begin (transaction)); - store.pending_put (transaction, rai::pending_key (1, 2), { 2, 3, rai::epoch::epoch_1 }); + store.pending_put (transaction, nano::pending_key (1, 2), { 2, 3, nano::epoch::epoch_1 }); auto current (store.pending_begin (transaction)); ASSERT_NE (store.pending_end (), current); - rai::pending_key key1 (current->first); - ASSERT_EQ (rai::account (1), key1.account); - ASSERT_EQ (rai::block_hash (2), key1.hash); - rai::pending_info pending (current->second); - ASSERT_EQ (rai::account (2), pending.source); - ASSERT_EQ (rai::amount (3), pending.amount); - ASSERT_EQ (rai::epoch::epoch_1, pending.epoch); + nano::pending_key key1 (current->first); + ASSERT_EQ (nano::account (1), key1.account); + ASSERT_EQ (nano::block_hash (2), key1.hash); + nano::pending_info pending (current->second); + ASSERT_EQ (nano::account (2), pending.source); + ASSERT_EQ (nano::amount (3), pending.amount); + ASSERT_EQ (nano::epoch::epoch_1, pending.epoch); } /** @@ -150,25 +150,25 @@ TEST (block_store, pending_iterator) TEST (block_store, pending_iterator_comparison) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::stat stats; + nano::stat stats; auto transaction (store.tx_begin (true)); // Populate pending - store.pending_put (transaction, rai::pending_key (rai::account (3), rai::block_hash (1)), rai::pending_info (rai::account (10), rai::amount (1), rai::epoch::epoch_0)); - store.pending_put (transaction, rai::pending_key (rai::account (3), rai::block_hash (4)), rai::pending_info (rai::account (10), rai::amount (0), rai::epoch::epoch_0)); + store.pending_put (transaction, nano::pending_key (nano::account (3), nano::block_hash (1)), nano::pending_info (nano::account (10), nano::amount (1), nano::epoch::epoch_0)); + store.pending_put (transaction, nano::pending_key (nano::account (3), nano::block_hash (4)), nano::pending_info (nano::account (10), nano::amount (0), nano::epoch::epoch_0)); // Populate pending_v1 - store.pending_put (transaction, rai::pending_key (rai::account (2), rai::block_hash (2)), rai::pending_info (rai::account (10), rai::amount (2), rai::epoch::epoch_1)); - store.pending_put (transaction, rai::pending_key (rai::account (2), rai::block_hash (3)), rai::pending_info (rai::account (10), rai::amount (3), rai::epoch::epoch_1)); + store.pending_put (transaction, nano::pending_key (nano::account (2), nano::block_hash (2)), nano::pending_info (nano::account (10), nano::amount (2), nano::epoch::epoch_1)); + store.pending_put (transaction, nano::pending_key (nano::account (2), nano::block_hash (3)), nano::pending_info (nano::account (10), nano::amount (3), nano::epoch::epoch_1)); // Iterate account 3 (pending) { size_t count = 0; - rai::account begin (3); - rai::account end (begin.number () + 1); - for (auto i (store.pending_begin (transaction, rai::pending_key (begin, 0))), n (store.pending_begin (transaction, rai::pending_key (end, 0))); i != n; ++i, ++count) + nano::account begin (3); + nano::account end (begin.number () + 1); + for (auto i (store.pending_begin (transaction, nano::pending_key (begin, 0))), n (store.pending_begin (transaction, nano::pending_key (end, 0))); i != n; ++i, ++count) { - rai::pending_key key (i->first); + nano::pending_key key (i->first); ASSERT_EQ (key.account, begin); ASSERT_LT (count, 3); } @@ -178,11 +178,11 @@ TEST (block_store, pending_iterator_comparison) // Iterate account 2 (pending_v1) { size_t count = 0; - rai::account begin (2); - rai::account end (begin.number () + 1); - for (auto i (store.pending_begin (transaction, rai::pending_key (begin, 0))), n (store.pending_begin (transaction, rai::pending_key (end, 0))); i != n; ++i, ++count) + nano::account begin (2); + nano::account end (begin.number () + 1); + for (auto i (store.pending_begin (transaction, nano::pending_key (begin, 0))), n (store.pending_begin (transaction, nano::pending_key (end, 0))); i != n; ++i, ++count) { - rai::pending_key key (i->first); + nano::pending_key key (i->first); ASSERT_EQ (key.account, begin); ASSERT_LT (count, 3); } @@ -193,32 +193,32 @@ TEST (block_store, pending_iterator_comparison) TEST (block_store, genesis) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::genesis genesis; + nano::genesis genesis; auto hash (genesis.hash ()); auto transaction (store.tx_begin (true)); store.initialize (transaction, genesis); - rai::account_info info; - ASSERT_FALSE (store.account_get (transaction, rai::genesis_account, info)); + nano::account_info info; + ASSERT_FALSE (store.account_get (transaction, nano::genesis_account, info)); ASSERT_EQ (hash, info.head); auto block1 (store.block_get (transaction, info.head)); ASSERT_NE (nullptr, block1); - auto receive1 (dynamic_cast (block1.get ())); + auto receive1 (dynamic_cast (block1.get ())); ASSERT_NE (nullptr, receive1); - ASSERT_LE (info.modified, rai::seconds_since_epoch ()); - auto test_pub_text (rai::test_genesis_key.pub.to_string ()); - auto test_pub_account (rai::test_genesis_key.pub.to_account ()); - auto test_prv_text (rai::test_genesis_key.prv.data.to_string ()); - ASSERT_EQ (rai::genesis_account, rai::test_genesis_key.pub); + ASSERT_LE (info.modified, nano::seconds_since_epoch ()); + auto test_pub_text (nano::test_genesis_key.pub.to_string ()); + auto test_pub_account (nano::test_genesis_key.pub.to_account ()); + auto test_prv_text (nano::test_genesis_key.prv.data.to_string ()); + ASSERT_EQ (nano::genesis_account, nano::test_genesis_key.pub); } TEST (representation, changes) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::keypair key1; + nano::keypair key1; auto transaction (store.tx_begin (true)); ASSERT_EQ (0, store.representation_get (transaction, key1.pub)); store.representation_put (transaction, key1.pub, 1); @@ -230,9 +230,9 @@ TEST (representation, changes) TEST (bootstrap, simple) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - auto block1 (std::make_shared (0, 1, 2, rai::keypair ().prv, 4, 5)); + auto block1 (std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5)); auto transaction (store.tx_begin (true)); auto block2 (store.unchecked_get (transaction, block1->previous ())); ASSERT_TRUE (block2.empty ()); @@ -240,7 +240,7 @@ TEST (bootstrap, simple) auto block3 (store.unchecked_get (transaction, block1->previous ())); ASSERT_FALSE (block3.empty ()); ASSERT_EQ (*block1, *block3[0]); - store.unchecked_del (transaction, rai::unchecked_key (block1->previous (), block1->hash ())); + store.unchecked_del (transaction, nano::unchecked_key (block1->previous (), block1->hash ())); auto block4 (store.unchecked_get (transaction, block1->previous ())); ASSERT_TRUE (block4.empty ()); } @@ -248,9 +248,9 @@ TEST (bootstrap, simple) TEST (unchecked, multiple) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - auto block1 (std::make_shared (4, 1, 2, rai::keypair ().prv, 4, 5)); + auto block1 (std::make_shared (4, 1, 2, nano::keypair ().prv, 4, 5)); auto transaction (store.tx_begin (true)); auto block2 (store.unchecked_get (transaction, block1->previous ())); ASSERT_TRUE (block2.empty ()); @@ -265,9 +265,9 @@ TEST (unchecked, multiple) TEST (unchecked, double_put) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - auto block1 (std::make_shared (4, 1, 2, rai::keypair ().prv, 4, 5)); + auto block1 (std::make_shared (4, 1, 2, nano::keypair ().prv, 4, 5)); auto transaction (store.tx_begin (true)); auto block2 (store.unchecked_get (transaction, block1->previous ())); ASSERT_TRUE (block2.empty ()); @@ -280,11 +280,11 @@ TEST (unchecked, double_put) TEST (unchecked, multiple_get) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - auto block1 (std::make_shared (4, 1, 2, rai::keypair ().prv, 4, 5)); - auto block2 (std::make_shared (3, 1, 2, rai::keypair ().prv, 4, 5)); - auto block3 (std::make_shared (5, 1, 2, rai::keypair ().prv, 4, 5)); + auto block1 (std::make_shared (4, 1, 2, nano::keypair ().prv, 4, 5)); + auto block2 (std::make_shared (3, 1, 2, nano::keypair ().prv, 4, 5)); + auto block3 (std::make_shared (5, 1, 2, nano::keypair ().prv, 4, 5)); { auto transaction (store.tx_begin (true)); store.unchecked_put (transaction, block1->previous (), block1); // unchecked1 @@ -299,7 +299,7 @@ TEST (unchecked, multiple_get) auto transaction (store.tx_begin ()); auto unchecked_count (store.unchecked_count (transaction)); ASSERT_EQ (unchecked_count, 8); - std::vector unchecked1; + std::vector unchecked1; auto unchecked1_blocks (store.unchecked_get (transaction, block1->previous ())); ASSERT_EQ (unchecked1_blocks.size (), 3); for (auto & i : unchecked1_blocks) @@ -309,7 +309,7 @@ TEST (unchecked, multiple_get) ASSERT_TRUE (std::find (unchecked1.begin (), unchecked1.end (), block1->hash ()) != unchecked1.end ()); ASSERT_TRUE (std::find (unchecked1.begin (), unchecked1.end (), block2->hash ()) != unchecked1.end ()); ASSERT_TRUE (std::find (unchecked1.begin (), unchecked1.end (), block3->hash ()) != unchecked1.end ()); - std::vector unchecked2; + std::vector unchecked2; auto unchecked2_blocks (store.unchecked_get (transaction, block1->hash ())); ASSERT_EQ (unchecked2_blocks.size (), 2); for (auto & i : unchecked2_blocks) @@ -331,25 +331,25 @@ TEST (unchecked, multiple_get) TEST (checksum, simple) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::block_hash hash0 (0); + nano::block_hash hash0 (0); auto transaction (store.tx_begin (true)); ASSERT_TRUE (store.checksum_get (transaction, 0x100, 0x10, hash0)); - rai::block_hash hash1 (0); + nano::block_hash hash1 (0); store.checksum_put (transaction, 0x100, 0x10, hash1); - rai::block_hash hash2; + nano::block_hash hash2; ASSERT_FALSE (store.checksum_get (transaction, 0x100, 0x10, hash2)); ASSERT_EQ (hash1, hash2); store.checksum_del (transaction, 0x100, 0x10); - rai::block_hash hash3; + nano::block_hash hash3; ASSERT_TRUE (store.checksum_get (transaction, 0x100, 0x10, hash3)); } TEST (block_store, empty_accounts) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); auto transaction (store.tx_begin ()); auto begin (store.latest_begin (transaction)); @@ -360,9 +360,9 @@ TEST (block_store, empty_accounts) TEST (block_store, one_block) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::open_block block1 (0, 1, 0, rai::keypair ().prv, 0, 0); + nano::open_block block1 (0, 1, 0, nano::keypair ().prv, 0, 0); auto transaction (store.tx_begin (true)); store.block_put (transaction, block1.hash (), block1); ASSERT_TRUE (store.block_exists (transaction, block1.hash ())); @@ -371,7 +371,7 @@ TEST (block_store, one_block) TEST (block_store, empty_bootstrap) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); auto transaction (store.tx_begin ()); auto begin (store.unchecked_begin (transaction)); @@ -382,16 +382,16 @@ TEST (block_store, empty_bootstrap) TEST (block_store, one_bootstrap) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - auto block1 (std::make_shared (0, 1, 2, rai::keypair ().prv, 4, 5)); + auto block1 (std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5)); auto transaction (store.tx_begin (true)); store.unchecked_put (transaction, block1->hash (), block1); store.flush (transaction); auto begin (store.unchecked_begin (transaction)); auto end (store.unchecked_end ()); ASSERT_NE (end, begin); - rai::uint256_union hash1 (begin->first.key ()); + nano::uint256_union hash1 (begin->first.key ()); ASSERT_EQ (block1->hash (), hash1); auto blocks (store.unchecked_get (transaction, hash1)); ASSERT_EQ (1, blocks.size ()); @@ -404,23 +404,23 @@ TEST (block_store, one_bootstrap) TEST (block_store, unchecked_begin_search) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::keypair key0; - rai::send_block block1 (0, 1, 2, key0.prv, key0.pub, 3); - rai::send_block block2 (5, 6, 7, key0.prv, key0.pub, 8); + nano::keypair key0; + nano::send_block block1 (0, 1, 2, key0.prv, key0.pub, 3); + nano::send_block block2 (5, 6, 7, key0.prv, key0.pub, 8); } TEST (block_store, frontier_retrieval) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::account account1 (0); - rai::account_info info1 (0, 0, 0, 0, 0, 0, rai::epoch::epoch_0); + nano::account account1 (0); + nano::account_info info1 (0, 0, 0, 0, 0, 0, nano::epoch::epoch_0); auto transaction (store.tx_begin (true)); store.account_put (transaction, account1, info1); - rai::account_info info2; + nano::account_info info2; store.account_get (transaction, account1, info2); ASSERT_EQ (info1, info2); } @@ -428,17 +428,17 @@ TEST (block_store, frontier_retrieval) TEST (block_store, one_account) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::account account (0); - rai::block_hash hash (0); + nano::account account (0); + nano::block_hash hash (0); auto transaction (store.tx_begin (true)); - store.account_put (transaction, account, { hash, account, hash, 42, 100, 200, rai::epoch::epoch_0 }); + store.account_put (transaction, account, { hash, account, hash, 42, 100, 200, nano::epoch::epoch_0 }); auto begin (store.latest_begin (transaction)); auto end (store.latest_end ()); ASSERT_NE (end, begin); - ASSERT_EQ (account, rai::account (begin->first)); - rai::account_info info (begin->second); + ASSERT_EQ (account, nano::account (begin->first)); + nano::account_info info (begin->second); ASSERT_EQ (hash, info.head); ASSERT_EQ (42, info.balance.number ()); ASSERT_EQ (100, info.modified); @@ -450,17 +450,17 @@ TEST (block_store, one_account) TEST (block_store, two_block) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::open_block block1 (0, 1, 1, rai::keypair ().prv, 0, 0); + nano::open_block block1 (0, 1, 1, nano::keypair ().prv, 0, 0); block1.hashables.account = 1; - std::vector hashes; - std::vector blocks; + std::vector hashes; + std::vector blocks; hashes.push_back (block1.hash ()); blocks.push_back (block1); auto transaction (store.tx_begin (true)); store.block_put (transaction, hashes[0], block1); - rai::open_block block2 (0, 1, 2, rai::keypair ().prv, 0, 0); + nano::open_block block2 (0, 1, 2, nano::keypair ().prv, 0, 0); hashes.push_back (block2.hash ()); blocks.push_back (block2); store.block_put (transaction, hashes[1], block2); @@ -471,28 +471,28 @@ TEST (block_store, two_block) TEST (block_store, two_account) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::account account1 (1); - rai::block_hash hash1 (2); - rai::account account2 (3); - rai::block_hash hash2 (4); + nano::account account1 (1); + nano::block_hash hash1 (2); + nano::account account2 (3); + nano::block_hash hash2 (4); auto transaction (store.tx_begin (true)); - store.account_put (transaction, account1, { hash1, account1, hash1, 42, 100, 300, rai::epoch::epoch_0 }); - store.account_put (transaction, account2, { hash2, account2, hash2, 84, 200, 400, rai::epoch::epoch_0 }); + store.account_put (transaction, account1, { hash1, account1, hash1, 42, 100, 300, nano::epoch::epoch_0 }); + store.account_put (transaction, account2, { hash2, account2, hash2, 84, 200, 400, nano::epoch::epoch_0 }); auto begin (store.latest_begin (transaction)); auto end (store.latest_end ()); ASSERT_NE (end, begin); - ASSERT_EQ (account1, rai::account (begin->first)); - rai::account_info info1 (begin->second); + ASSERT_EQ (account1, nano::account (begin->first)); + nano::account_info info1 (begin->second); ASSERT_EQ (hash1, info1.head); ASSERT_EQ (42, info1.balance.number ()); ASSERT_EQ (100, info1.modified); ASSERT_EQ (300, info1.block_count); ++begin; ASSERT_NE (end, begin); - ASSERT_EQ (account2, rai::account (begin->first)); - rai::account_info info2 (begin->second); + ASSERT_EQ (account2, nano::account (begin->first)); + nano::account_info info2 (begin->second); ASSERT_EQ (hash2, info2.head); ASSERT_EQ (84, info2.balance.number ()); ASSERT_EQ (200, info2.modified); @@ -504,15 +504,15 @@ TEST (block_store, two_account) TEST (block_store, latest_find) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::account account1 (1); - rai::block_hash hash1 (2); - rai::account account2 (3); - rai::block_hash hash2 (4); + nano::account account1 (1); + nano::block_hash hash1 (2); + nano::account account2 (3); + nano::block_hash hash2 (4); auto transaction (store.tx_begin (true)); - store.account_put (transaction, account1, { hash1, account1, hash1, 100, 0, 300, rai::epoch::epoch_0 }); - store.account_put (transaction, account2, { hash2, account2, hash2, 200, 0, 400, rai::epoch::epoch_0 }); + store.account_put (transaction, account1, { hash1, account1, hash1, 100, 0, 300, nano::epoch::epoch_0 }); + store.account_put (transaction, account2, { hash2, account2, hash2, 200, 0, 400, nano::epoch::epoch_0 }); auto first (store.latest_begin (transaction)); auto second (store.latest_begin (transaction)); ++second; @@ -527,84 +527,84 @@ TEST (block_store, latest_find) TEST (block_store, bad_path) { bool init (false); - rai::mdb_store store (init, boost::filesystem::path ("///")); + nano::mdb_store store (init, boost::filesystem::path ("///")); ASSERT_TRUE (init); } TEST (block_store, DISABLED_already_open) // File can be shared { - auto path (rai::unique_path ()); + auto path (nano::unique_path ()); boost::filesystem::create_directories (path.parent_path ()); - rai::set_secure_perm_directory (path.parent_path ()); + nano::set_secure_perm_directory (path.parent_path ()); std::ofstream file; file.open (path.string ().c_str ()); ASSERT_TRUE (file.is_open ()); bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); ASSERT_TRUE (init); } TEST (block_store, roots) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::send_block send_block (0, 1, 2, rai::keypair ().prv, 4, 5); + nano::send_block send_block (0, 1, 2, nano::keypair ().prv, 4, 5); ASSERT_EQ (send_block.hashables.previous, send_block.root ()); - rai::change_block change_block (0, 1, rai::keypair ().prv, 3, 4); + nano::change_block change_block (0, 1, nano::keypair ().prv, 3, 4); ASSERT_EQ (change_block.hashables.previous, change_block.root ()); - rai::receive_block receive_block (0, 1, rai::keypair ().prv, 3, 4); + nano::receive_block receive_block (0, 1, nano::keypair ().prv, 3, 4); ASSERT_EQ (receive_block.hashables.previous, receive_block.root ()); - rai::open_block open_block (0, 1, 2, rai::keypair ().prv, 4, 5); + nano::open_block open_block (0, 1, 2, nano::keypair ().prv, 4, 5); ASSERT_EQ (open_block.hashables.account, open_block.root ()); } TEST (block_store, pending_exists) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::pending_key two (2, 0); - rai::pending_info pending; + nano::pending_key two (2, 0); + nano::pending_info pending; auto transaction (store.tx_begin (true)); store.pending_put (transaction, two, pending); - rai::pending_key one (1, 0); + nano::pending_key one (1, 0); ASSERT_FALSE (store.pending_exists (transaction, one)); } TEST (block_store, latest_exists) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::block_hash two (2); - rai::account_info info; + nano::block_hash two (2); + nano::account_info info; auto transaction (store.tx_begin (true)); store.account_put (transaction, two, info); - rai::block_hash one (1); + nano::block_hash one (1); ASSERT_FALSE (store.account_exists (transaction, one)); } TEST (block_store, large_iteration) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - std::unordered_set accounts1; + std::unordered_set accounts1; for (auto i (0); i < 1000; ++i) { auto transaction (store.tx_begin (true)); - rai::account account; - rai::random_pool.GenerateBlock (account.bytes.data (), account.bytes.size ()); + nano::account account; + nano::random_pool.GenerateBlock (account.bytes.data (), account.bytes.size ()); accounts1.insert (account); - store.account_put (transaction, account, rai::account_info ()); + store.account_put (transaction, account, nano::account_info ()); } - std::unordered_set accounts2; - rai::account previous (0); + std::unordered_set accounts2; + nano::account previous (0); auto transaction (store.tx_begin ()); for (auto i (store.latest_begin (transaction, 0)), n (store.latest_end ()); i != n; ++i) { - rai::account current (i->first); + nano::account current (i->first); assert (current.number () > previous.number ()); accounts2.insert (current); previous = current; @@ -615,11 +615,11 @@ TEST (block_store, large_iteration) TEST (block_store, frontier) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); auto transaction (store.tx_begin (true)); - rai::block_hash hash (100); - rai::account account (200); + nano::block_hash hash (100); + nano::account account (200); ASSERT_TRUE (store.frontier_get (transaction, hash).is_zero ()); store.frontier_put (transaction, hash, account); ASSERT_EQ (account, store.frontier_get (transaction, hash)); @@ -630,10 +630,10 @@ TEST (block_store, frontier) TEST (block_store, block_replace) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::send_block send1 (0, 0, 0, rai::keypair ().prv, 0, 1); - rai::send_block send2 (0, 0, 0, rai::keypair ().prv, 0, 2); + nano::send_block send1 (0, 0, 0, nano::keypair ().prv, 0, 1); + nano::send_block send2 (0, 0, 0, nano::keypair ().prv, 0, 2); auto transaction (store.tx_begin (true)); store.block_put (transaction, 0, send1); store.block_put (transaction, 0, send2); @@ -645,12 +645,12 @@ TEST (block_store, block_replace) TEST (block_store, block_count) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); auto transaction (store.tx_begin (true)); ASSERT_EQ (0, store.block_count (transaction).sum ()); - rai::open_block block (0, 1, 0, rai::keypair ().prv, 0, 0); - rai::uint256_union hash1 (block.hash ()); + nano::open_block block (0, 1, 0, nano::keypair ().prv, 0, 0); + nano::uint256_union hash1 (block.hash ()); store.block_put (transaction, hash1, block); ASSERT_EQ (1, store.block_count (transaction).sum ()); } @@ -658,23 +658,23 @@ TEST (block_store, block_count) TEST (block_store, account_count) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); auto transaction (store.tx_begin (true)); ASSERT_EQ (0, store.account_count (transaction)); - rai::account account (200); - store.account_put (transaction, account, rai::account_info ()); + nano::account account (200); + store.account_put (transaction, account, nano::account_info ()); ASSERT_EQ (1, store.account_count (transaction)); } TEST (block_store, sequence_increment) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::keypair key1; - rai::keypair key2; - auto block1 (std::make_shared (0, 1, 0, rai::keypair ().prv, 0, 0)); + nano::keypair key1; + nano::keypair key2; + auto block1 (std::make_shared (0, 1, 0, nano::keypair ().prv, 0, 0)); auto transaction (store.tx_begin (true)); auto vote1 (store.vote_generate (transaction, key1.pub, key1.prv, block1)); ASSERT_EQ (1, vote1->sequence); @@ -698,117 +698,117 @@ TEST (block_store, sequence_increment) TEST (block_store, upgrade_v2_v3) { - rai::keypair key1; - rai::keypair key2; - rai::block_hash change_hash; - auto path (rai::unique_path ()); + nano::keypair key1; + nano::keypair key2; + nano::block_hash change_hash; + auto path (nano::unique_path ()); { bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); ASSERT_TRUE (!init); auto transaction (store.tx_begin (true)); - rai::genesis genesis; + nano::genesis genesis; auto hash (genesis.hash ()); store.initialize (transaction, genesis); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::change_block change (hash, key1.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::change_block change (hash, key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); change_hash = change.hash (); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, change).code); - ASSERT_EQ (0, ledger.weight (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, key1.pub)); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change).code); + ASSERT_EQ (0, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, key1.pub)); store.version_put (transaction, 2); store.representation_put (transaction, key1.pub, 7); ASSERT_EQ (7, ledger.weight (transaction, key1.pub)); ASSERT_EQ (2, store.version_get (transaction)); store.representation_put (transaction, key2.pub, 6); ASSERT_EQ (6, ledger.weight (transaction, key2.pub)); - rai::account_info info; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info)); + nano::account_info info; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info)); info.rep_block = 42; - rai::account_info_v5 info_old (info.head, info.rep_block, info.open_block, info.balance, info.modified); - auto status (mdb_put (store.env.tx (transaction), store.accounts_v0, rai::mdb_val (rai::test_genesis_key.pub), info_old.val (), 0)); + nano::account_info_v5 info_old (info.head, info.rep_block, info.open_block, info.balance, info.modified); + auto status (mdb_put (store.env.tx (transaction), store.accounts_v0, nano::mdb_val (nano::test_genesis_key.pub), info_old.val (), 0)); assert (status == 0); } bool init (false); - rai::mdb_store store (init, path); - rai::stat stats; - rai::ledger ledger (store, stats); + nano::mdb_store store (init, path); + nano::stat stats; + nano::ledger ledger (store, stats); auto transaction (store.tx_begin (true)); ASSERT_TRUE (!init); ASSERT_LT (2, store.version_get (transaction)); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, key1.pub)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, key1.pub)); ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - rai::account_info info; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info)); + nano::account_info info; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info)); ASSERT_EQ (change_hash, info.rep_block); } TEST (block_store, upgrade_v3_v4) { - rai::keypair key1; - rai::keypair key2; - rai::keypair key3; - auto path (rai::unique_path ()); + nano::keypair key1; + nano::keypair key2; + nano::keypair key3; + auto path (nano::unique_path ()); { bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); ASSERT_FALSE (init); auto transaction (store.tx_begin (true)); store.version_put (transaction, 3); - rai::pending_info_v3 info (key1.pub, 100, key2.pub); - auto status (mdb_put (store.env.tx (transaction), store.pending_v0, rai::mdb_val (key3.pub), info.val (), 0)); + nano::pending_info_v3 info (key1.pub, 100, key2.pub); + auto status (mdb_put (store.env.tx (transaction), store.pending_v0, nano::mdb_val (key3.pub), info.val (), 0)); ASSERT_EQ (0, status); } bool init (false); - rai::mdb_store store (init, path); - rai::stat stats; - rai::ledger ledger (store, stats); + nano::mdb_store store (init, path); + nano::stat stats; + nano::ledger ledger (store, stats); auto transaction (store.tx_begin (true)); ASSERT_FALSE (init); ASSERT_LT (3, store.version_get (transaction)); - rai::pending_key key (key2.pub, key3.pub); - rai::pending_info info; + nano::pending_key key (key2.pub, key3.pub); + nano::pending_info info; auto error (store.pending_get (transaction, key, info)); ASSERT_FALSE (error); ASSERT_EQ (key1.pub, info.source); - ASSERT_EQ (rai::amount (100), info.amount); - ASSERT_EQ (rai::epoch::epoch_0, info.epoch); + ASSERT_EQ (nano::amount (100), info.amount); + ASSERT_EQ (nano::epoch::epoch_0, info.epoch); } TEST (block_store, upgrade_v4_v5) { - rai::block_hash genesis_hash (0); - rai::block_hash hash (0); - auto path (rai::unique_path ()); + nano::block_hash genesis_hash (0); + nano::block_hash hash (0); + auto path (nano::unique_path ()); { bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); ASSERT_FALSE (init); auto transaction (store.tx_begin (true)); - rai::genesis genesis; - rai::stat stats; - rai::ledger ledger (store, stats); + nano::genesis genesis; + nano::stat stats; + nano::ledger ledger (store, stats); store.initialize (transaction, genesis); store.version_put (transaction, 4); - rai::account_info info; - store.account_get (transaction, rai::test_genesis_key.pub, info); - rai::keypair key0; - rai::send_block block0 (info.head, key0.pub, rai::genesis_amount - rai::Gxrb_ratio, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block0).code); + nano::account_info info; + store.account_get (transaction, nano::test_genesis_key.pub, info); + nano::keypair key0; + nano::send_block block0 (info.head, key0.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block0).code); hash = block0.hash (); auto original (store.block_get (transaction, info.head)); genesis_hash = info.head; store.block_successor_clear (transaction, info.head); ASSERT_TRUE (store.block_successor (transaction, genesis_hash).is_zero ()); - rai::account_info info2; - store.account_get (transaction, rai::test_genesis_key.pub, info2); - rai::account_info_v5 info_old (info2.head, info2.rep_block, info2.open_block, info2.balance, info2.modified); - auto status (mdb_put (store.env.tx (transaction), store.accounts_v0, rai::mdb_val (rai::test_genesis_key.pub), info_old.val (), 0)); + nano::account_info info2; + store.account_get (transaction, nano::test_genesis_key.pub, info2); + nano::account_info_v5 info_old (info2.head, info2.rep_block, info2.open_block, info2.balance, info2.modified); + auto status (mdb_put (store.env.tx (transaction), store.accounts_v0, nano::mdb_val (nano::test_genesis_key.pub), info_old.val (), 0)); assert (status == 0); } bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); ASSERT_FALSE (init); auto transaction (store.tx_begin ()); ASSERT_EQ (hash, store.block_successor (transaction, genesis_hash)); @@ -817,9 +817,9 @@ TEST (block_store, upgrade_v4_v5) TEST (block_store, block_random) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::genesis genesis; + nano::genesis genesis; auto transaction (store.tx_begin (true)); store.initialize (transaction, genesis); auto block (store.block_random (transaction)); @@ -829,48 +829,48 @@ TEST (block_store, block_random) TEST (block_store, upgrade_v5_v6) { - auto path (rai::unique_path ()); + auto path (nano::unique_path ()); { bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); ASSERT_FALSE (init); auto transaction (store.tx_begin (true)); - rai::genesis genesis; + nano::genesis genesis; store.initialize (transaction, genesis); store.version_put (transaction, 5); - rai::account_info info; - store.account_get (transaction, rai::test_genesis_key.pub, info); - rai::account_info_v5 info_old (info.head, info.rep_block, info.open_block, info.balance, info.modified); - auto status (mdb_put (store.env.tx (transaction), store.accounts_v0, rai::mdb_val (rai::test_genesis_key.pub), info_old.val (), 0)); + nano::account_info info; + store.account_get (transaction, nano::test_genesis_key.pub, info); + nano::account_info_v5 info_old (info.head, info.rep_block, info.open_block, info.balance, info.modified); + auto status (mdb_put (store.env.tx (transaction), store.accounts_v0, nano::mdb_val (nano::test_genesis_key.pub), info_old.val (), 0)); assert (status == 0); } bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); ASSERT_FALSE (init); auto transaction (store.tx_begin ()); - rai::account_info info; - store.account_get (transaction, rai::test_genesis_key.pub, info); + nano::account_info info; + store.account_get (transaction, nano::test_genesis_key.pub, info); ASSERT_EQ (1, info.block_count); } TEST (block_store, upgrade_v6_v7) { - auto path (rai::unique_path ()); + auto path (nano::unique_path ()); { bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); ASSERT_FALSE (init); auto transaction (store.tx_begin (true)); - rai::genesis genesis; + nano::genesis genesis; store.initialize (transaction, genesis); store.version_put (transaction, 6); - auto send1 (std::make_shared (0, 0, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + auto send1 (std::make_shared (0, 0, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); store.unchecked_put (transaction, send1->hash (), send1); store.flush (transaction); ASSERT_NE (store.unchecked_end (), store.unchecked_begin (transaction)); } bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); ASSERT_FALSE (init); auto transaction (store.tx_begin ()); ASSERT_EQ (store.unchecked_end (), store.unchecked_begin (transaction)); @@ -879,14 +879,14 @@ TEST (block_store, upgrade_v6_v7) // Databases need to be dropped in order to convert to dupsort compatible TEST (block_store, DISABLED_change_dupsort) // Unchecked is no longer dupsort table { - auto path (rai::unique_path ()); + auto path (nano::unique_path ()); bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); auto transaction (store.tx_begin (true)); ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked, 1)); ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE, &store.unchecked)); - auto send1 (std::make_shared (0, 0, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - auto send2 (std::make_shared (1, 0, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + auto send1 (std::make_shared (0, 0, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + auto send2 (std::make_shared (1, 0, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); ASSERT_NE (send1->hash (), send2->hash ()); store.unchecked_put (transaction, send1->hash (), send1); store.unchecked_put (transaction, send1->hash (), send2); @@ -923,21 +923,21 @@ TEST (block_store, DISABLED_change_dupsort) // Unchecked is no longer dupsort ta TEST (block_store, upgrade_v7_v8) { - auto path (rai::unique_path ()); + auto path (nano::unique_path ()); { bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); auto transaction (store.tx_begin (true)); ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked, 1)); ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE, &store.unchecked)); store.version_put (transaction, 7); } bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); ASSERT_FALSE (init); auto transaction (store.tx_begin (true)); - auto send1 (std::make_shared (0, 0, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - auto send2 (std::make_shared (1, 0, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + auto send1 (std::make_shared (0, 0, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + auto send2 (std::make_shared (1, 0, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); store.unchecked_put (transaction, send1->hash (), send1); store.unchecked_put (transaction, send1->hash (), send2); store.flush (transaction); @@ -952,13 +952,13 @@ TEST (block_store, upgrade_v7_v8) TEST (block_store, sequence_flush) { - auto path (rai::unique_path ()); + auto path (nano::unique_path ()); bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); ASSERT_FALSE (init); auto transaction (store.tx_begin (true)); - rai::keypair key1; - auto send1 (std::make_shared (0, 0, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + nano::keypair key1; + auto send1 (std::make_shared (0, 0, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); auto vote1 (store.vote_generate (transaction, key1.pub, key1.prv, send1)); auto seq2 (store.vote_get (transaction, vote1->account)); ASSERT_EQ (nullptr, seq2); @@ -969,14 +969,14 @@ TEST (block_store, sequence_flush) TEST (block_store, sequence_flush_by_hash) { - auto path (rai::unique_path ()); + auto path (nano::unique_path ()); bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); ASSERT_FALSE (init); auto transaction (store.tx_begin_write ()); - rai::keypair key1; - std::vector blocks1; - blocks1.push_back (rai::genesis ().hash ()); + nano::keypair key1; + std::vector blocks1; + blocks1.push_back (nano::genesis ().hash ()); blocks1.push_back (1234); blocks1.push_back (5678); auto vote1 (store.vote_generate (transaction, key1.pub, key1.prv, blocks1)); @@ -990,20 +990,20 @@ TEST (block_store, sequence_flush_by_hash) // Upgrading tracking block sequence numbers to whole vote. TEST (block_store, upgrade_v8_v9) { - auto path (rai::unique_path ()); - rai::keypair key; + auto path (nano::unique_path ()); + nano::keypair key; { bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); auto transaction (store.tx_begin (true)); ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.vote, 1)); ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "sequence", MDB_CREATE, &store.vote)); uint64_t sequence (10); - ASSERT_EQ (0, mdb_put (store.env.tx (transaction), store.vote, rai::mdb_val (key.pub), rai::mdb_val (sizeof (sequence), &sequence), 0)); + ASSERT_EQ (0, mdb_put (store.env.tx (transaction), store.vote, nano::mdb_val (key.pub), nano::mdb_val (sizeof (sequence), &sequence), 0)); store.version_put (transaction, 8); } bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); ASSERT_FALSE (init); auto transaction (store.tx_begin ()); ASSERT_LT (8, store.version_get (transaction)); @@ -1014,60 +1014,60 @@ TEST (block_store, upgrade_v8_v9) TEST (block_store, upgrade_v9_v10) { - auto path (rai::unique_path ()); - rai::block_hash hash (0); + auto path (nano::unique_path ()); + nano::block_hash hash (0); { bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); ASSERT_FALSE (init); auto transaction (store.tx_begin (true)); - rai::genesis genesis; - rai::stat stats; - rai::ledger ledger (store, stats); + nano::genesis genesis; + nano::stat stats; + nano::ledger ledger (store, stats); store.initialize (transaction, genesis); store.version_put (transaction, 9); - rai::account_info info; - store.account_get (transaction, rai::test_genesis_key.pub, info); - rai::keypair key0; - rai::uint128_t balance (rai::genesis_amount); + nano::account_info info; + store.account_get (transaction, nano::test_genesis_key.pub, info); + nano::keypair key0; + nano::uint128_t balance (nano::genesis_amount); hash = info.head; for (auto i (1); i < 32; ++i) // Making 31 send blocks (+ 1 open = 32 total) { - balance = balance - rai::Gxrb_ratio; - rai::send_block block0 (hash, key0.pub, balance, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block0).code); + balance = balance - nano::Gxrb_ratio; + nano::send_block block0 (hash, key0.pub, balance, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block0).code); hash = block0.hash (); } - rai::block_info block_info_auto; // Checking automatic block_info creation for block 32 + nano::block_info block_info_auto; // Checking automatic block_info creation for block 32 store.block_info_get (transaction, hash, block_info_auto); - ASSERT_EQ (block_info_auto.account, rai::test_genesis_key.pub); + ASSERT_EQ (block_info_auto.account, nano::test_genesis_key.pub); ASSERT_EQ (block_info_auto.balance.number (), balance); ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.blocks_info, 0)); // Cleaning blocks_info subdatabase bool block_info_exists (store.block_info_exists (transaction, hash)); ASSERT_EQ (block_info_exists, 0); // Checking if automatic block_info is deleted } bool init (false); - rai::mdb_store store (init, path); + nano::mdb_store store (init, path); ASSERT_FALSE (init); auto transaction (store.tx_begin ()); ASSERT_LT (9, store.version_get (transaction)); - rai::block_info block_info; + nano::block_info block_info; store.block_info_get (transaction, hash, block_info); - ASSERT_EQ (block_info.account, rai::test_genesis_key.pub); - ASSERT_EQ (block_info.balance.number (), rai::genesis_amount - rai::Gxrb_ratio * 31); + ASSERT_EQ (block_info.account, nano::test_genesis_key.pub); + ASSERT_EQ (block_info.balance.number (), nano::genesis_amount - nano::Gxrb_ratio * 31); } TEST (block_store, state_block) { bool error (false); - rai::mdb_store store (error, rai::unique_path ()); + nano::mdb_store store (error, nano::unique_path ()); ASSERT_FALSE (error); - rai::genesis genesis; + nano::genesis genesis; auto transaction (store.tx_begin (true)); store.initialize (transaction, genesis); - rai::keypair key1; - rai::state_block block1 (1, genesis.hash (), 3, 4, 6, key1.prv, key1.pub, 7); - ASSERT_EQ (rai::block_type::state, block1.type ()); + nano::keypair key1; + nano::state_block block1 (1, genesis.hash (), 3, 4, 6, key1.prv, key1.pub, 7); + ASSERT_EQ (nano::block_type::state, block1.type ()); store.block_put (transaction, block1.hash (), block1); ASSERT_TRUE (store.block_exists (transaction, block1.hash ())); auto block2 (store.block_get (transaction, block1.hash ())); diff --git a/nano/core_test/conflicts.cpp b/nano/core_test/conflicts.cpp new file mode 100644 index 00000000..590dcd40 --- /dev/null +++ b/nano/core_test/conflicts.cpp @@ -0,0 +1,175 @@ +#include +#include + +TEST (conflicts, start_stop) +{ + nano::system system (24000, 1); + auto & node1 (*system.nodes[0]); + nano::genesis genesis; + nano::keypair key1; + auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*send1); + ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); + ASSERT_EQ (0, node1.active.roots.size ()); + node1.active.start (send1); + ASSERT_EQ (1, node1.active.roots.size ()); + auto root1 (send1->root ()); + auto existing1 (node1.active.roots.find (root1)); + ASSERT_NE (node1.active.roots.end (), existing1); + auto votes1 (existing1->election); + ASSERT_NE (nullptr, votes1); + ASSERT_EQ (1, votes1->last_votes.size ()); +} + +TEST (conflicts, add_existing) +{ + nano::system system (24000, 1); + auto & node1 (*system.nodes[0]); + nano::genesis genesis; + nano::keypair key1; + auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*send1); + ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); + node1.active.start (send1); + nano::keypair key2; + auto send2 (std::make_shared (genesis.hash (), key2.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.active.start (send2); + ASSERT_EQ (1, node1.active.roots.size ()); + auto vote1 (std::make_shared (key2.pub, key2.prv, 0, send2)); + node1.active.vote (vote1); + ASSERT_EQ (1, node1.active.roots.size ()); + auto votes1 (node1.active.roots.find (send2->root ())->election); + ASSERT_NE (nullptr, votes1); + ASSERT_EQ (2, votes1->last_votes.size ()); + ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (key2.pub)); +} + +TEST (conflicts, add_two) +{ + nano::system system (24000, 1); + auto & node1 (*system.nodes[0]); + nano::genesis genesis; + nano::keypair key1; + auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*send1); + ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); + node1.active.start (send1); + nano::keypair key2; + auto send2 (std::make_shared (send1->hash (), key2.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*send2); + ASSERT_EQ (nano::process_result::progress, node1.process (*send2).code); + node1.active.start (send2); + ASSERT_EQ (2, node1.active.roots.size ()); +} + +TEST (vote_uniquer, null) +{ + nano::block_uniquer block_uniquer; + nano::vote_uniquer uniquer (block_uniquer); + ASSERT_EQ (nullptr, uniquer.unique (nullptr)); +} + +// Show that an identical vote can be uniqued +TEST (vote_uniquer, same_vote) +{ + nano::block_uniquer block_uniquer; + nano::vote_uniquer uniquer (block_uniquer); + nano::keypair key; + auto vote1 (std::make_shared (key.pub, key.prv, 0, std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0))); + auto vote2 (std::make_shared (*vote1)); + ASSERT_EQ (vote1, uniquer.unique (vote1)); + ASSERT_EQ (vote1, uniquer.unique (vote2)); +} + +// Show that a different vote for the same block will have the block uniqued +TEST (vote_uniquer, same_block) +{ + nano::block_uniquer block_uniquer; + nano::vote_uniquer uniquer (block_uniquer); + nano::keypair key1; + nano::keypair key2; + auto block1 (std::make_shared (0, 0, 0, 0, 0, key1.prv, key1.pub, 0)); + auto block2 (std::make_shared (*block1)); + auto vote1 (std::make_shared (key1.pub, key1.prv, 0, block1)); + auto vote2 (std::make_shared (key1.pub, key1.prv, 0, block2)); + ASSERT_EQ (vote1, uniquer.unique (vote1)); + ASSERT_EQ (vote2, uniquer.unique (vote2)); + ASSERT_NE (vote1, vote2); + ASSERT_EQ (boost::get> (vote1->blocks[0]), boost::get> (vote2->blocks[0])); +} + +TEST (vote_uniquer, vbh_one) +{ + nano::block_uniquer block_uniquer; + nano::vote_uniquer uniquer (block_uniquer); + nano::keypair key; + auto block (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0)); + std::vector hashes; + hashes.push_back (block->hash ()); + auto vote1 (std::make_shared (key.pub, key.prv, 0, hashes)); + auto vote2 (std::make_shared (*vote1)); + ASSERT_EQ (vote1, uniquer.unique (vote1)); + ASSERT_EQ (vote1, uniquer.unique (vote2)); +} + +TEST (vote_uniquer, vbh_two) +{ + nano::block_uniquer block_uniquer; + nano::vote_uniquer uniquer (block_uniquer); + nano::keypair key; + auto block1 (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0)); + std::vector hashes1; + hashes1.push_back (block1->hash ()); + auto block2 (std::make_shared (1, 0, 0, 0, 0, key.prv, key.pub, 0)); + std::vector hashes2; + hashes2.push_back (block2->hash ()); + auto vote1 (std::make_shared (key.pub, key.prv, 0, hashes1)); + auto vote2 (std::make_shared (key.pub, key.prv, 0, hashes2)); + ASSERT_EQ (vote1, uniquer.unique (vote1)); + ASSERT_EQ (vote2, uniquer.unique (vote2)); +} + +TEST (vote_uniquer, cleanup) +{ + nano::block_uniquer block_uniquer; + nano::vote_uniquer uniquer (block_uniquer); + nano::keypair key; + auto vote1 (std::make_shared (key.pub, key.prv, 0, std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0))); + auto vote2 (std::make_shared (key.pub, key.prv, 1, std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0))); + auto vote3 (uniquer.unique (vote1)); + auto vote4 (uniquer.unique (vote2)); + vote2.reset (); + vote4.reset (); + ASSERT_EQ (2, uniquer.size ()); + auto iterations (0); + while (uniquer.size () == 2) + { + auto vote5 (uniquer.unique (vote1)); + ASSERT_LT (iterations++, 200); + } +} + +TEST (conflicts, reprioritize) +{ + nano::system system (24000, 1); + auto & node1 (*system.nodes[0]); + nano::genesis genesis; + nano::keypair key1; + auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*send1); + uint64_t difficulty1; + nano::work_validate (*send1, &difficulty1); + node1.process_active (send1); + node1.block_processor.flush (); + auto existing1 (node1.active.roots.find (send1->root ())); + ASSERT_NE (node1.active.roots.end (), existing1); + ASSERT_EQ (difficulty1, existing1->difficulty); + node1.work_generate_blocking (*send1, difficulty1); + uint64_t difficulty2; + nano::work_validate (*send1, &difficulty2); + node1.process_active (send1); + node1.block_processor.flush (); + auto existing2 (node1.active.roots.find (send1->root ())); + ASSERT_NE (node1.active.roots.end (), existing2); + ASSERT_EQ (difficulty2, existing2->difficulty); +} diff --git a/rai/core_test/daemon.cpp b/nano/core_test/daemon.cpp similarity index 100% rename from rai/core_test/daemon.cpp rename to nano/core_test/daemon.cpp diff --git a/rai/core_test/entry.cpp b/nano/core_test/entry.cpp similarity index 100% rename from rai/core_test/entry.cpp rename to nano/core_test/entry.cpp diff --git a/rai/core_test/gap_cache.cpp b/nano/core_test/gap_cache.cpp similarity index 56% rename from rai/core_test/gap_cache.cpp rename to nano/core_test/gap_cache.cpp index d68a1b8b..7a30cc48 100644 --- a/rai/core_test/gap_cache.cpp +++ b/nano/core_test/gap_cache.cpp @@ -1,23 +1,23 @@ #include -#include -#include +#include +#include using namespace std::chrono_literals; TEST (gap_cache, add_new) { - rai::system system (24000, 1); - rai::gap_cache cache (*system.nodes[0]); - auto block1 (std::make_shared (0, 1, 2, rai::keypair ().prv, 4, 5)); + nano::system system (24000, 1); + nano::gap_cache cache (*system.nodes[0]); + auto block1 (std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5)); auto transaction (system.nodes[0]->store.tx_begin (true)); cache.add (transaction, block1); } TEST (gap_cache, add_existing) { - rai::system system (24000, 1); - rai::gap_cache cache (*system.nodes[0]); - auto block1 (std::make_shared (0, 1, 2, rai::keypair ().prv, 4, 5)); + nano::system system (24000, 1); + nano::gap_cache cache (*system.nodes[0]); + auto block1 (std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5)); auto transaction (system.nodes[0]->store.tx_begin (true)); cache.add (transaction, block1); auto existing1 (cache.blocks.get<1> ().find (block1->hash ())); @@ -34,9 +34,9 @@ TEST (gap_cache, add_existing) TEST (gap_cache, comparison) { - rai::system system (24000, 1); - rai::gap_cache cache (*system.nodes[0]); - auto block1 (std::make_shared (1, 0, 2, rai::keypair ().prv, 4, 5)); + nano::system system (24000, 1); + nano::gap_cache cache (*system.nodes[0]); + auto block1 (std::make_shared (1, 0, 2, nano::keypair ().prv, 4, 5)); auto transaction (system.nodes[0]->store.tx_begin (true)); cache.add (transaction, block1); auto existing1 (cache.blocks.get<1> ().find (block1->hash ())); @@ -44,7 +44,7 @@ TEST (gap_cache, comparison) auto arrival (existing1->arrival); while (std::chrono::steady_clock::now () == arrival) ; - auto block3 (std::make_shared (0, 42, 1, rai::keypair ().prv, 3, 4)); + auto block3 (std::make_shared (0, 42, 1, nano::keypair ().prv, 3, 4)); cache.add (transaction, block3); ASSERT_EQ (2, cache.blocks.size ()); auto existing2 (cache.blocks.get<1> ().find (block3->hash ())); @@ -55,22 +55,22 @@ TEST (gap_cache, comparison) TEST (gap_cache, gap_bootstrap) { - rai::system system (24000, 2); - rai::block_hash latest (system.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::keypair key; - auto send (std::make_shared (latest, key.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (latest))); + nano::system system (24000, 2); + nano::block_hash latest (system.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::keypair key; + auto send (std::make_shared (latest, key.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (latest))); { auto transaction (system.nodes[0]->store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->block_processor.process_receive_one (transaction, send).code); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->block_processor.process_receive_one (transaction, send).code); } - ASSERT_EQ (rai::genesis_amount - 100, system.nodes[0]->balance (rai::genesis_account)); - ASSERT_EQ (rai::genesis_amount, system.nodes[1]->balance (rai::genesis_account)); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + ASSERT_EQ (nano::genesis_amount - 100, system.nodes[0]->balance (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, system.nodes[1]->balance (nano::genesis_account)); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - auto latest_block (system.wallet (0)->send_action (rai::test_genesis_key.pub, key.pub, 100)); + auto latest_block (system.wallet (0)->send_action (nano::test_genesis_key.pub, key.pub, 100)); ASSERT_NE (nullptr, latest_block); - ASSERT_EQ (rai::genesis_amount - 200, system.nodes[0]->balance (rai::genesis_account)); - ASSERT_EQ (rai::genesis_amount, system.nodes[1]->balance (rai::genesis_account)); + ASSERT_EQ (nano::genesis_amount - 200, system.nodes[0]->balance (nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, system.nodes[1]->balance (nano::genesis_account)); system.deadline_set (10s); { // The separate publish and vote system doesn't work very well here because it's instantly confirmed. @@ -78,7 +78,7 @@ TEST (gap_cache, gap_bootstrap) auto transaction (system.nodes[0]->store.tx_begin ()); system.nodes[0]->network.republish_block (latest_block); } - while (system.nodes[1]->balance (rai::genesis_account) != rai::genesis_amount - 200) + while (system.nodes[1]->balance (nano::genesis_account) != nano::genesis_amount - 200) { ASSERT_NO_ERROR (system.poll ()); } @@ -86,12 +86,12 @@ TEST (gap_cache, gap_bootstrap) TEST (gap_cache, two_dependencies) { - rai::system system (24000, 1); - rai::keypair key; - rai::genesis genesis; - auto send1 (std::make_shared (genesis.hash (), key.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); - auto send2 (std::make_shared (send1->hash (), key.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (send1->hash ()))); - auto open (std::make_shared (send1->hash (), key.pub, key.pub, key.prv, key.pub, system.work.generate (key.pub))); + nano::system system (24000, 1); + nano::keypair key; + nano::genesis genesis; + auto send1 (std::make_shared (genesis.hash (), key.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + auto send2 (std::make_shared (send1->hash (), key.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (send1->hash ()))); + auto open (std::make_shared (send1->hash (), key.pub, key.pub, key.prv, key.pub, system.work.generate (key.pub))); ASSERT_EQ (0, system.nodes[0]->gap_cache.blocks.size ()); system.nodes[0]->block_processor.add (send2, std::chrono::steady_clock::now ()); system.nodes[0]->block_processor.flush (); diff --git a/rai/core_test/interface.cpp b/nano/core_test/interface.cpp similarity index 79% rename from rai/core_test/interface.cpp rename to nano/core_test/interface.cpp index c6e2ce03..560cd3b4 100644 --- a/rai/core_test/interface.cpp +++ b/nano/core_test/interface.cpp @@ -2,14 +2,14 @@ #include -#include -#include -#include -#include +#include +#include +#include +#include TEST (interface, xrb_uint128_to_dec) { - rai::uint128_union zero (0); + nano::uint128_union zero (0); char text[40] = { 0 }; xrb_uint128_to_dec (zero.bytes.data (), text); ASSERT_STREQ ("0", text); @@ -17,7 +17,7 @@ TEST (interface, xrb_uint128_to_dec) TEST (interface, xrb_uint256_to_string) { - rai::uint256_union zero (0); + nano::uint256_union zero (0); char text[65] = { 0 }; xrb_uint256_to_string (zero.bytes.data (), text); ASSERT_STREQ ("0000000000000000000000000000000000000000000000000000000000000000", text); @@ -25,7 +25,7 @@ TEST (interface, xrb_uint256_to_string) TEST (interface, xrb_uint256_to_address) { - rai::uint256_union zero (0); + nano::uint256_union zero (0); char text[65] = { 0 }; xrb_uint256_to_address (zero.bytes.data (), text); ASSERT_STREQ ("xrb_1111111111111111111111111111111111111111111111111111hifc8npp", text); @@ -33,7 +33,7 @@ TEST (interface, xrb_uint256_to_address) TEST (interface, xrb_uint512_to_string) { - rai::uint512_union zero (0); + nano::uint512_union zero (0); char text[129] = { 0 }; xrb_uint512_to_string (zero.bytes.data (), text); ASSERT_STREQ ("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", text); @@ -41,7 +41,7 @@ TEST (interface, xrb_uint512_to_string) TEST (interface, xrb_uint128_from_dec) { - rai::uint128_union zero (0); + nano::uint128_union zero (0); ASSERT_EQ (0, xrb_uint128_from_dec ("340282366920938463463374607431768211455", zero.bytes.data ())); ASSERT_EQ (1, xrb_uint128_from_dec ("340282366920938463463374607431768211456", zero.bytes.data ())); ASSERT_EQ (1, xrb_uint128_from_dec ("3402823669209384634633%4607431768211455", zero.bytes.data ())); @@ -49,7 +49,7 @@ TEST (interface, xrb_uint128_from_dec) TEST (interface, xrb_uint256_from_string) { - rai::uint256_union zero (0); + nano::uint256_union zero (0); ASSERT_EQ (0, xrb_uint256_from_string ("0000000000000000000000000000000000000000000000000000000000000000", zero.bytes.data ())); ASSERT_EQ (1, xrb_uint256_from_string ("00000000000000000000000000000000000000000000000000000000000000000", zero.bytes.data ())); ASSERT_EQ (1, xrb_uint256_from_string ("000000000000000000000000000%000000000000000000000000000000000000", zero.bytes.data ())); @@ -57,7 +57,7 @@ TEST (interface, xrb_uint256_from_string) TEST (interface, xrb_uint512_from_string) { - rai::uint512_union zero (0); + nano::uint512_union zero (0); ASSERT_EQ (0, xrb_uint512_from_string ("00000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", zero.bytes.data ())); ASSERT_EQ (1, xrb_uint512_from_string ("000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000", zero.bytes.data ())); ASSERT_EQ (1, xrb_uint512_from_string ("0000000000000000000000000000000000000000000000000000000000%000000000000000000000000000000000000000000000000000000000000000000000", zero.bytes.data ())); @@ -72,48 +72,48 @@ TEST (interface, xrb_valid_address) TEST (interface, xrb_seed_create) { - rai::uint256_union seed; + nano::uint256_union seed; xrb_generate_random (seed.bytes.data ()); ASSERT_FALSE (seed.is_zero ()); } TEST (interface, xrb_seed_key) { - rai::uint256_union seed (0); - rai::uint256_union prv; + nano::uint256_union seed (0); + nano::uint256_union prv; xrb_seed_key (seed.bytes.data (), 0, prv.bytes.data ()); ASSERT_FALSE (prv.is_zero ()); } TEST (interface, xrb_key_account) { - rai::uint256_union prv (0); - rai::uint256_union pub; + nano::uint256_union prv (0); + nano::uint256_union pub; xrb_key_account (prv.bytes.data (), pub.bytes.data ()); ASSERT_FALSE (pub.is_zero ()); } TEST (interface, sign_transaction) { - rai::raw_key key; + nano::raw_key key; xrb_generate_random (key.data.bytes.data ()); - rai::uint256_union pub; + nano::uint256_union pub; xrb_key_account (key.data.bytes.data (), pub.bytes.data ()); - rai::send_block send (0, 0, 0, key, pub, 0); - ASSERT_FALSE (rai::validate_message (pub, send.hash (), send.signature)); + nano::send_block send (0, 0, 0, key, pub, 0); + ASSERT_FALSE (nano::validate_message (pub, send.hash (), send.signature)); send.signature.bytes[0] ^= 1; - ASSERT_TRUE (rai::validate_message (pub, send.hash (), send.signature)); + ASSERT_TRUE (nano::validate_message (pub, send.hash (), send.signature)); auto send_json (send.to_json ()); auto transaction (xrb_sign_transaction (send_json.c_str (), key.data.bytes.data ())); boost::property_tree::ptree block_l; std::string transaction_l (transaction); std::stringstream block_stream (transaction_l); boost::property_tree::read_json (block_stream, block_l); - auto block (rai::deserialize_block_json (block_l)); + auto block (nano::deserialize_block_json (block_l)); ASSERT_NE (nullptr, block); - auto send1 (dynamic_cast (block.get ())); + auto send1 (dynamic_cast (block.get ())); ASSERT_NE (nullptr, send1); - ASSERT_FALSE (rai::validate_message (pub, send.hash (), send1->signature)); + ASSERT_FALSE (nano::validate_message (pub, send.hash (), send1->signature)); // Signatures should be non-deterministic auto transaction2 (xrb_sign_transaction (send_json.c_str (), key.data.bytes.data ())); ASSERT_NE (0, strcmp (transaction, transaction2)); @@ -123,30 +123,30 @@ TEST (interface, sign_transaction) TEST (interface, fail_sign_transaction) { - rai::uint256_union data (0); + nano::uint256_union data (0); xrb_sign_transaction ("", data.bytes.data ()); } TEST (interface, work_transaction) { - rai::raw_key key; + nano::raw_key key; xrb_generate_random (key.data.bytes.data ()); - rai::uint256_union pub; + nano::uint256_union pub; xrb_key_account (key.data.bytes.data (), pub.bytes.data ()); - rai::send_block send (1, 0, 0, key, pub, 0); + nano::send_block send (1, 0, 0, key, pub, 0); auto transaction (xrb_work_transaction (send.to_json ().c_str ())); boost::property_tree::ptree block_l; std::string transaction_l (transaction); std::stringstream block_stream (transaction_l); boost::property_tree::read_json (block_stream, block_l); - auto block (rai::deserialize_block_json (block_l)); + auto block (nano::deserialize_block_json (block_l)); ASSERT_NE (nullptr, block); - ASSERT_FALSE (rai::work_validate (*block)); + ASSERT_FALSE (nano::work_validate (*block)); free (transaction); } TEST (interface, fail_work_transaction) { - rai::uint256_union data (0); + nano::uint256_union data (0); xrb_work_transaction (""); } diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp new file mode 100644 index 00000000..30922fcc --- /dev/null +++ b/nano/core_test/ledger.cpp @@ -0,0 +1,2434 @@ +#include +#include +#include +#include +#include +#include + +using namespace std::chrono_literals; + +// Init returns an error if it can't open files at the path +TEST (ledger, store_error) +{ + bool init (false); + nano::mdb_store store (init, boost::filesystem::path ("///")); + ASSERT_FALSE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); +} + +// Ledger can be initialized and returns a basic query for an empty account +TEST (ledger, empty) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::account account; + auto transaction (store.tx_begin ()); + auto balance (ledger.account_balance (transaction, account)); + ASSERT_TRUE (balance.is_zero ()); +} + +// Genesis account should have the max balance on empty initialization +TEST (ledger, genesis_balance) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + auto balance (ledger.account_balance (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, balance); + auto amount (ledger.amount (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, amount); + nano::account_info info; + ASSERT_FALSE (store.account_get (transaction, nano::genesis_account, info)); + // Frontier time should have been updated when genesis balance was added + ASSERT_GE (nano::seconds_since_epoch (), info.modified); + ASSERT_LT (nano::seconds_since_epoch () - info.modified, 10); +} + +// Make sure the checksum is the same when ledger reloaded +TEST (ledger, checksum_persistence) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::uint256_union checksum1; + nano::uint256_union max; + max.qwords[0] = 0; + max.qwords[0] = ~max.qwords[0]; + max.qwords[1] = 0; + max.qwords[1] = ~max.qwords[1]; + max.qwords[2] = 0; + max.qwords[2] = ~max.qwords[2]; + max.qwords[3] = 0; + max.qwords[3] = ~max.qwords[3]; + nano::stat stats; + auto transaction (store.tx_begin (true)); + { + nano::ledger ledger (store, stats); + nano::genesis genesis; + store.initialize (transaction, genesis); + checksum1 = ledger.checksum (transaction, 0, max); + } + nano::ledger ledger (store, stats); + ASSERT_EQ (checksum1, ledger.checksum (transaction, 0, max)); +} + +// All nodes in the system should agree on the genesis balance +TEST (system, system_genesis) +{ + nano::system system (24000, 2); + for (auto & i : system.nodes) + { + auto transaction (i->store.tx_begin ()); + ASSERT_EQ (nano::genesis_amount, i->ledger.account_balance (transaction, nano::genesis_account)); + } +} + +// Create a send block and publish it. +TEST (ledger, process_send) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + auto transaction (store.tx_begin (true)); + nano::genesis genesis; + store.initialize (transaction, genesis); + nano::account_info info1; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info1)); + nano::keypair key2; + nano::send_block send (info1.head, key2.pub, 50, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::block_hash hash1 (send.hash ()); + ASSERT_EQ (nano::test_genesis_key.pub, store.frontier_get (transaction, info1.head)); + ASSERT_EQ (1, info1.block_count); + // This was a valid block, it should progress. + auto return1 (ledger.process (transaction, send)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.amount (transaction, hash1)); + ASSERT_TRUE (store.frontier_get (transaction, info1.head).is_zero ()); + ASSERT_EQ (nano::test_genesis_key.pub, store.frontier_get (transaction, hash1)); + ASSERT_EQ (nano::process_result::progress, return1.code); + ASSERT_EQ (nano::test_genesis_key.pub, return1.account); + ASSERT_EQ (nano::genesis_amount - 50, return1.amount.number ()); + ASSERT_EQ (50, ledger.account_balance (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.account_pending (transaction, key2.pub)); + nano::account_info info2; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info2)); + ASSERT_EQ (2, info2.block_count); + auto latest6 (store.block_get (transaction, info2.head)); + ASSERT_NE (nullptr, latest6); + auto latest7 (dynamic_cast (latest6.get ())); + ASSERT_NE (nullptr, latest7); + ASSERT_EQ (send, *latest7); + // Create an open block opening an account accepting the send we just created + nano::open_block open (hash1, key2.pub, key2.pub, key2.prv, key2.pub, 0); + nano::block_hash hash2 (open.hash ()); + // This was a valid block, it should progress. + auto return2 (ledger.process (transaction, open)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.amount (transaction, hash2)); + ASSERT_EQ (nano::process_result::progress, return2.code); + ASSERT_EQ (key2.pub, return2.account); + ASSERT_EQ (nano::genesis_amount - 50, return2.amount.number ()); + ASSERT_EQ (key2.pub, store.frontier_get (transaction, hash2)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); + ASSERT_EQ (0, ledger.account_pending (transaction, key2.pub)); + ASSERT_EQ (50, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (transaction, key2.pub)); + nano::account_info info3; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info3)); + auto latest2 (store.block_get (transaction, info3.head)); + ASSERT_NE (nullptr, latest2); + auto latest3 (dynamic_cast (latest2.get ())); + ASSERT_NE (nullptr, latest3); + ASSERT_EQ (send, *latest3); + nano::account_info info4; + ASSERT_FALSE (store.account_get (transaction, key2.pub, info4)); + auto latest4 (store.block_get (transaction, info4.head)); + ASSERT_NE (nullptr, latest4); + auto latest5 (dynamic_cast (latest4.get ())); + ASSERT_NE (nullptr, latest5); + ASSERT_EQ (open, *latest5); + ledger.rollback (transaction, hash2); + ASSERT_TRUE (store.frontier_get (transaction, hash2).is_zero ()); + nano::account_info info5; + ASSERT_TRUE (ledger.store.account_get (transaction, key2.pub, info5)); + nano::pending_info pending1; + ASSERT_FALSE (ledger.store.pending_get (transaction, nano::pending_key (key2.pub, hash1), pending1)); + ASSERT_EQ (nano::test_genesis_key.pub, pending1.source); + ASSERT_EQ (nano::genesis_amount - 50, pending1.amount.number ()); + ASSERT_EQ (0, ledger.account_balance (transaction, key2.pub)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.account_pending (transaction, key2.pub)); + ASSERT_EQ (50, ledger.account_balance (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (50, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); + nano::account_info info6; + ASSERT_FALSE (ledger.store.account_get (transaction, nano::test_genesis_key.pub, info6)); + ASSERT_EQ (hash1, info6.head); + ledger.rollback (transaction, info6.head); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (nano::test_genesis_key.pub, store.frontier_get (transaction, info1.head)); + ASSERT_TRUE (store.frontier_get (transaction, hash1).is_zero ()); + nano::account_info info7; + ASSERT_FALSE (ledger.store.account_get (transaction, nano::test_genesis_key.pub, info7)); + ASSERT_EQ (1, info7.block_count); + ASSERT_EQ (info1.head, info7.head); + nano::pending_info pending2; + ASSERT_TRUE (ledger.store.pending_get (transaction, nano::pending_key (key2.pub, hash1), pending2)); + ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.account_pending (transaction, key2.pub)); +} + +TEST (ledger, process_receive) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::account_info info1; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info1)); + nano::keypair key2; + nano::send_block send (info1.head, key2.pub, 50, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::block_hash hash1 (send.hash ()); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); + nano::keypair key3; + nano::open_block open (hash1, key3.pub, key2.pub, key2.prv, key2.pub, 0); + nano::block_hash hash2 (open.hash ()); + auto return1 (ledger.process (transaction, open)); + ASSERT_EQ (nano::process_result::progress, return1.code); + ASSERT_EQ (key2.pub, return1.account); + ASSERT_EQ (nano::genesis_amount - 50, return1.amount.number ()); + ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (transaction, key3.pub)); + nano::send_block send2 (hash1, key2.pub, 25, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::block_hash hash3 (send2.hash ()); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); + nano::receive_block receive (hash2, hash3, key2.prv, key2.pub, 0); + auto hash4 (receive.hash ()); + ASSERT_EQ (key2.pub, store.frontier_get (transaction, hash2)); + auto return2 (ledger.process (transaction, receive)); + ASSERT_EQ (25, ledger.amount (transaction, hash4)); + ASSERT_TRUE (store.frontier_get (transaction, hash2).is_zero ()); + ASSERT_EQ (key2.pub, store.frontier_get (transaction, hash4)); + ASSERT_EQ (nano::process_result::progress, return2.code); + ASSERT_EQ (key2.pub, return2.account); + ASSERT_EQ (25, return2.amount.number ()); + ASSERT_EQ (hash4, ledger.latest (transaction, key2.pub)); + ASSERT_EQ (25, ledger.account_balance (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.account_pending (transaction, key2.pub)); + ASSERT_EQ (nano::genesis_amount - 25, ledger.account_balance (transaction, key2.pub)); + ASSERT_EQ (nano::genesis_amount - 25, ledger.weight (transaction, key3.pub)); + ledger.rollback (transaction, hash4); + ASSERT_TRUE (store.block_successor (transaction, hash2).is_zero ()); + ASSERT_EQ (key2.pub, store.frontier_get (transaction, hash2)); + ASSERT_TRUE (store.frontier_get (transaction, hash4).is_zero ()); + ASSERT_EQ (25, ledger.account_balance (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (25, ledger.account_pending (transaction, key2.pub)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (hash2, ledger.latest (transaction, key2.pub)); + nano::pending_info pending1; + ASSERT_FALSE (ledger.store.pending_get (transaction, nano::pending_key (key2.pub, hash3), pending1)); + ASSERT_EQ (nano::test_genesis_key.pub, pending1.source); + ASSERT_EQ (25, pending1.amount.number ()); +} + +TEST (ledger, rollback_receiver) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::account_info info1; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info1)); + nano::keypair key2; + nano::send_block send (info1.head, key2.pub, 50, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::block_hash hash1 (send.hash ()); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); + nano::keypair key3; + nano::open_block open (hash1, key3.pub, key2.pub, key2.prv, key2.pub, 0); + nano::block_hash hash2 (open.hash ()); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); + ASSERT_EQ (hash2, ledger.latest (transaction, key2.pub)); + ASSERT_EQ (50, ledger.account_balance (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); + ASSERT_EQ (50, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (transaction, key3.pub)); + ledger.rollback (transaction, hash1); + ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.account_balance (transaction, key2.pub)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); + nano::account_info info2; + ASSERT_TRUE (ledger.store.account_get (transaction, key2.pub, info2)); + nano::pending_info pending1; + ASSERT_TRUE (ledger.store.pending_get (transaction, nano::pending_key (key2.pub, info2.head), pending1)); +} + +TEST (ledger, rollback_representation) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key5; + nano::change_block change1 (genesis.hash (), key5.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change1).code); + nano::keypair key3; + nano::change_block change2 (change1.hash (), key3.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change2).code); + nano::keypair key2; + nano::send_block send1 (change2.hash (), key2.pub, 50, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::keypair key4; + nano::open_block open (send1.hash (), key4.pub, key2.pub, key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); + nano::send_block send2 (send1.hash (), key2.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); + nano::receive_block receive1 (open.hash (), send2.hash (), key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); + ASSERT_EQ (1, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (nano::genesis_amount - 1, ledger.weight (transaction, key4.pub)); + nano::account_info info1; + ASSERT_FALSE (store.account_get (transaction, key2.pub, info1)); + ASSERT_EQ (open.hash (), info1.rep_block); + ledger.rollback (transaction, receive1.hash ()); + nano::account_info info2; + ASSERT_FALSE (store.account_get (transaction, key2.pub, info2)); + ASSERT_EQ (open.hash (), info2.rep_block); + ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (transaction, key4.pub)); + ledger.rollback (transaction, open.hash ()); + ASSERT_EQ (1, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (0, ledger.weight (transaction, key4.pub)); + ledger.rollback (transaction, send1.hash ()); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, key3.pub)); + nano::account_info info3; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info3)); + ASSERT_EQ (change2.hash (), info3.rep_block); + ledger.rollback (transaction, change2.hash ()); + nano::account_info info4; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info4)); + ASSERT_EQ (change1.hash (), info4.rep_block); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, key5.pub)); + ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); +} + +TEST (ledger, receive_rollback) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::send_block send (genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); + nano::receive_block receive (send.hash (), send.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code); + ledger.rollback (transaction, receive.hash ()); +} + +TEST (ledger, process_duplicate) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::account_info info1; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info1)); + nano::keypair key2; + nano::send_block send (info1.head, key2.pub, 50, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::block_hash hash1 (send.hash ()); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); + ASSERT_EQ (nano::process_result::old, ledger.process (transaction, send).code); + nano::open_block open (hash1, 1, key2.pub, key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); + ASSERT_EQ (nano::process_result::old, ledger.process (transaction, open).code); +} + +TEST (ledger, representative_genesis) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + auto latest (ledger.latest (transaction, nano::test_genesis_key.pub)); + ASSERT_FALSE (latest.is_zero ()); + ASSERT_EQ (genesis.open->hash (), ledger.representative (transaction, latest)); +} + +TEST (ledger, weight) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); +} + +TEST (ledger, representative_change) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::keypair key2; + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); + nano::account_info info1; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info1)); + nano::change_block block (info1.head, key2.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::test_genesis_key.pub, store.frontier_get (transaction, info1.head)); + auto return1 (ledger.process (transaction, block)); + ASSERT_EQ (0, ledger.amount (transaction, block.hash ())); + ASSERT_TRUE (store.frontier_get (transaction, info1.head).is_zero ()); + ASSERT_EQ (nano::test_genesis_key.pub, store.frontier_get (transaction, block.hash ())); + ASSERT_EQ (nano::process_result::progress, return1.code); + ASSERT_EQ (nano::test_genesis_key.pub, return1.account); + ASSERT_EQ (0, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, key2.pub)); + nano::account_info info2; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info2)); + ASSERT_EQ (block.hash (), info2.head); + ledger.rollback (transaction, info2.head); + ASSERT_EQ (nano::test_genesis_key.pub, store.frontier_get (transaction, info1.head)); + ASSERT_TRUE (store.frontier_get (transaction, block.hash ()).is_zero ()); + nano::account_info info3; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info3)); + ASSERT_EQ (info1.head, info3.head); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); +} + +TEST (ledger, send_fork) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::keypair key2; + nano::keypair key3; + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::account_info info1; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info1)); + nano::send_block block (info1.head, key2.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block).code); + nano::send_block block2 (info1.head, key3.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, block2).code); +} + +TEST (ledger, receive_fork) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::keypair key2; + nano::keypair key3; + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::account_info info1; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info1)); + nano::send_block block (info1.head, key2.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block).code); + nano::open_block block2 (block.hash (), key2.pub, key2.pub, key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); + nano::change_block block3 (block2.hash (), key3.pub, key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code); + nano::send_block block4 (block.hash (), key2.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block4).code); + nano::receive_block block5 (block2.hash (), block4.hash (), key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, block5).code); +} + +TEST (ledger, open_fork) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::keypair key2; + nano::keypair key3; + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::account_info info1; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info1)); + nano::send_block block (info1.head, key2.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block).code); + nano::open_block block2 (block.hash (), key2.pub, key2.pub, key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); + nano::open_block block3 (block.hash (), key3.pub, key2.pub, key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, block3).code); +} + +TEST (ledger, checksum_single) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + nano::stat stats; + nano::ledger ledger (store, stats); + store.initialize (transaction, genesis); + store.checksum_put (transaction, 0, 0, genesis.hash ()); + ASSERT_EQ (genesis.hash (), ledger.checksum (transaction, 0, std::numeric_limits::max ())); + nano::change_block block1 (ledger.latest (transaction, nano::test_genesis_key.pub), nano::account (1), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::checksum check1 (ledger.checksum (transaction, 0, std::numeric_limits::max ())); + ASSERT_EQ (genesis.hash (), check1); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); + nano::checksum check2 (ledger.checksum (transaction, 0, std::numeric_limits::max ())); + ASSERT_EQ (block1.hash (), check2); +} + +TEST (ledger, checksum_two) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + nano::stat stats; + nano::ledger ledger (store, stats); + store.initialize (transaction, genesis); + store.checksum_put (transaction, 0, 0, genesis.hash ()); + nano::keypair key2; + nano::send_block block1 (ledger.latest (transaction, nano::test_genesis_key.pub), key2.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); + nano::checksum check1 (ledger.checksum (transaction, 0, std::numeric_limits::max ())); + nano::open_block block2 (block1.hash (), 1, key2.pub, key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); + nano::checksum check2 (ledger.checksum (transaction, 0, std::numeric_limits::max ())); + ASSERT_EQ (check1, check2 ^ block2.hash ()); +} + +TEST (ledger, DISABLED_checksum_range) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + auto transaction (store.tx_begin ()); + nano::checksum check1 (ledger.checksum (transaction, 0, std::numeric_limits::max ())); + ASSERT_TRUE (check1.is_zero ()); + nano::block_hash hash1 (42); + nano::checksum check2 (ledger.checksum (transaction, 0, 42)); + ASSERT_TRUE (check2.is_zero ()); + nano::checksum check3 (ledger.checksum (transaction, 42, std::numeric_limits::max ())); + ASSERT_EQ (hash1, check3); +} + +TEST (system, DISABLED_generate_send_existing) +{ + nano::system system (24000, 1); + nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair stake_preserver; + auto send_block (system.wallet (0)->send_action (nano::genesis_account, stake_preserver.pub, nano::genesis_amount / 3 * 2, true)); + nano::account_info info1; + { + auto transaction (system.wallet (0)->wallets.tx_begin ()); + ASSERT_FALSE (system.nodes[0]->store.account_get (transaction, nano::test_genesis_key.pub, info1)); + } + std::vector accounts; + accounts.push_back (nano::test_genesis_key.pub); + system.generate_send_existing (*system.nodes[0], accounts); + // Have stake_preserver receive funds after generate_send_existing so it isn't chosen as the destination + { + auto transaction (system.nodes[0]->store.tx_begin (true)); + auto open_block (std::make_shared (send_block->hash (), nano::genesis_account, stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0)); + system.nodes[0]->work_generate_blocking (*open_block); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->ledger.process (transaction, *open_block).code); + } + ASSERT_GT (system.nodes[0]->balance (stake_preserver.pub), system.nodes[0]->balance (nano::genesis_account)); + nano::account_info info2; + { + auto transaction (system.wallet (0)->wallets.tx_begin ()); + ASSERT_FALSE (system.nodes[0]->store.account_get (transaction, nano::test_genesis_key.pub, info2)); + } + ASSERT_NE (info1.head, info2.head); + system.deadline_set (15s); + while (info2.block_count < info1.block_count + 2) + { + ASSERT_NO_ERROR (system.poll ()); + auto transaction (system.wallet (0)->wallets.tx_begin ()); + ASSERT_FALSE (system.nodes[0]->store.account_get (transaction, nano::test_genesis_key.pub, info2)); + } + ASSERT_EQ (info1.block_count + 2, info2.block_count); + ASSERT_EQ (info2.balance, nano::genesis_amount / 3); + { + auto transaction (system.wallet (0)->wallets.tx_begin ()); + ASSERT_NE (system.nodes[0]->ledger.amount (transaction, info2.head), 0); + } + system.stop (); + runner.join (); +} + +TEST (system, generate_send_new) +{ + nano::system system (24000, 1); + nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + { + auto transaction (system.nodes[0]->store.tx_begin ()); + auto iterator1 (system.nodes[0]->store.latest_begin (transaction)); + ASSERT_NE (system.nodes[0]->store.latest_end (), iterator1); + ++iterator1; + ASSERT_EQ (system.nodes[0]->store.latest_end (), iterator1); + } + nano::keypair stake_preserver; + auto send_block (system.wallet (0)->send_action (nano::genesis_account, stake_preserver.pub, nano::genesis_amount / 3 * 2, true)); + { + auto transaction (system.nodes[0]->store.tx_begin (true)); + auto open_block (std::make_shared (send_block->hash (), nano::genesis_account, stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0)); + system.nodes[0]->work_generate_blocking (*open_block); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->ledger.process (transaction, *open_block).code); + } + ASSERT_GT (system.nodes[0]->balance (stake_preserver.pub), system.nodes[0]->balance (nano::genesis_account)); + std::vector accounts; + accounts.push_back (nano::test_genesis_key.pub); + system.generate_send_new (*system.nodes[0], accounts); + nano::account new_account (0); + { + auto transaction (system.nodes[0]->store.tx_begin ()); + auto iterator2 (system.wallet (0)->store.begin (transaction)); + if (nano::uint256_union (iterator2->first) != nano::test_genesis_key.pub) + { + new_account = nano::uint256_union (iterator2->first); + } + ++iterator2; + ASSERT_NE (system.wallet (0)->store.end (), iterator2); + if (nano::uint256_union (iterator2->first) != nano::test_genesis_key.pub) + { + new_account = nano::uint256_union (iterator2->first); + } + ++iterator2; + ASSERT_EQ (system.wallet (0)->store.end (), iterator2); + ASSERT_FALSE (new_account.is_zero ()); + } + system.deadline_set (10s); + while (system.nodes[0]->balance (new_account) == 0) + { + ASSERT_NO_ERROR (system.poll ()); + } + system.stop (); + runner.join (); +} + +TEST (ledger, representation) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + ASSERT_EQ (nano::genesis_amount, store.representation_get (transaction, nano::test_genesis_key.pub)); + nano::keypair key2; + nano::send_block block1 (genesis.hash (), key2.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); + ASSERT_EQ (nano::genesis_amount - 100, store.representation_get (transaction, nano::test_genesis_key.pub)); + nano::keypair key3; + nano::open_block block2 (block1.hash (), key3.pub, key2.pub, key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); + ASSERT_EQ (nano::genesis_amount - 100, store.representation_get (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); + ASSERT_EQ (100, store.representation_get (transaction, key3.pub)); + nano::send_block block3 (block1.hash (), key2.pub, nano::genesis_amount - 200, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code); + ASSERT_EQ (nano::genesis_amount - 200, store.representation_get (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); + ASSERT_EQ (100, store.representation_get (transaction, key3.pub)); + nano::receive_block block4 (block2.hash (), block3.hash (), key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block4).code); + ASSERT_EQ (nano::genesis_amount - 200, store.representation_get (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); + ASSERT_EQ (200, store.representation_get (transaction, key3.pub)); + nano::keypair key4; + nano::change_block block5 (block4.hash (), key4.pub, key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block5).code); + ASSERT_EQ (nano::genesis_amount - 200, store.representation_get (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key3.pub)); + ASSERT_EQ (200, store.representation_get (transaction, key4.pub)); + nano::keypair key5; + nano::send_block block6 (block5.hash (), key5.pub, 100, key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block6).code); + ASSERT_EQ (nano::genesis_amount - 200, store.representation_get (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key3.pub)); + ASSERT_EQ (100, store.representation_get (transaction, key4.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key5.pub)); + nano::keypair key6; + nano::open_block block7 (block6.hash (), key6.pub, key5.pub, key5.prv, key5.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block7).code); + ASSERT_EQ (nano::genesis_amount - 200, store.representation_get (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key3.pub)); + ASSERT_EQ (100, store.representation_get (transaction, key4.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key5.pub)); + ASSERT_EQ (100, store.representation_get (transaction, key6.pub)); + nano::send_block block8 (block6.hash (), key5.pub, 0, key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block8).code); + ASSERT_EQ (nano::genesis_amount - 200, store.representation_get (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key3.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key4.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key5.pub)); + ASSERT_EQ (100, store.representation_get (transaction, key6.pub)); + nano::receive_block block9 (block7.hash (), block8.hash (), key5.prv, key5.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block9).code); + ASSERT_EQ (nano::genesis_amount - 200, store.representation_get (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key3.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key4.pub)); + ASSERT_EQ (0, store.representation_get (transaction, key5.pub)); + ASSERT_EQ (200, store.representation_get (transaction, key6.pub)); +} + +TEST (ledger, double_open) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key2; + nano::send_block send1 (genesis.hash (), key2.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::open_block open1 (send1.hash (), key2.pub, key2.pub, key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); + nano::open_block open2 (send1.hash (), nano::test_genesis_key.pub, key2.pub, key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, open2).code); +} + +TEST (ledegr, double_receive) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key2; + nano::send_block send1 (genesis.hash (), key2.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::open_block open1 (send1.hash (), key2.pub, key2.pub, key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); + nano::receive_block receive1 (open1.hash (), send1.hash (), key2.prv, key2.pub, 0); + ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, receive1).code); +} + +TEST (votes, check_signature) +{ + nano::system system (24000, 1); + auto & node1 (*system.nodes[0]); + nano::genesis genesis; + nano::keypair key1; + auto send1 (std::make_shared (genesis.hash (), key1.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*send1); + auto transaction (node1.store.tx_begin (true)); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); + auto node_l (system.nodes[0]); + node1.active.start (send1); + auto votes1 (node1.active.roots.find (send1->root ())->election); + ASSERT_EQ (1, votes1->last_votes.size ()); + std::unique_lock lock (node1.active.mutex); + auto vote1 (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 1, send1)); + vote1->signature.bytes[0] ^= 1; + ASSERT_EQ (nano::vote_code::invalid, node1.vote_processor.vote_blocking (transaction, vote1, nano::endpoint (boost::asio::ip::address_v6 (), 0))); + vote1->signature.bytes[0] ^= 1; + ASSERT_EQ (nano::vote_code::vote, node1.vote_processor.vote_blocking (transaction, vote1, nano::endpoint (boost::asio::ip::address_v6 (), 0))); + ASSERT_EQ (nano::vote_code::replay, node1.vote_processor.vote_blocking (transaction, vote1, nano::endpoint (boost::asio::ip::address_v6 (), 0))); +} + +TEST (votes, add_one) +{ + nano::system system (24000, 1); + auto & node1 (*system.nodes[0]); + nano::genesis genesis; + nano::keypair key1; + auto send1 (std::make_shared (genesis.hash (), key1.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*send1); + auto transaction (node1.store.tx_begin (true)); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); + node1.active.start (send1); + auto votes1 (node1.active.roots.find (send1->root ())->election); + ASSERT_EQ (1, votes1->last_votes.size ()); + auto vote1 (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 1, send1)); + ASSERT_FALSE (node1.active.vote (vote1)); + auto vote2 (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 2, send1)); + ASSERT_FALSE (node1.active.vote (vote2)); + ASSERT_EQ (2, votes1->last_votes.size ()); + auto existing1 (votes1->last_votes.find (nano::test_genesis_key.pub)); + ASSERT_NE (votes1->last_votes.end (), existing1); + ASSERT_EQ (send1->hash (), existing1->second.hash); + auto winner (*votes1->tally (transaction).begin ()); + ASSERT_EQ (*send1, *winner.second); + ASSERT_EQ (nano::genesis_amount - 100, winner.first); +} + +TEST (votes, add_two) +{ + nano::system system (24000, 1); + auto & node1 (*system.nodes[0]); + nano::genesis genesis; + nano::keypair key1; + auto send1 (std::make_shared (genesis.hash (), key1.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*send1); + auto transaction (node1.store.tx_begin (true)); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); + node1.active.start (send1); + auto votes1 (node1.active.roots.find (send1->root ())->election); + auto vote1 (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 1, send1)); + ASSERT_FALSE (node1.active.vote (vote1)); + nano::keypair key2; + auto send2 (std::make_shared (genesis.hash (), key2.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + auto vote2 (std::make_shared (key2.pub, key2.prv, 1, send2)); + ASSERT_FALSE (node1.active.vote (vote2)); + ASSERT_EQ (3, votes1->last_votes.size ()); + ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (nano::test_genesis_key.pub)); + ASSERT_EQ (send1->hash (), votes1->last_votes[nano::test_genesis_key.pub].hash); + ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (key2.pub)); + ASSERT_EQ (send2->hash (), votes1->last_votes[key2.pub].hash); + auto winner (*votes1->tally (transaction).begin ()); + ASSERT_EQ (*send1, *winner.second); +} + +// Higher sequence numbers change the vote +TEST (votes, add_existing) +{ + nano::system system (24000, 1); + auto & node1 (*system.nodes[0]); + nano::genesis genesis; + nano::keypair key1; + auto send1 (std::make_shared (genesis.hash (), key1.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*send1); + auto transaction (node1.store.tx_begin (true)); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); + node1.active.start (send1); + auto votes1 (node1.active.roots.find (send1->root ())->election); + auto vote1 (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 1, send1)); + ASSERT_FALSE (node1.active.vote (vote1)); + ASSERT_FALSE (node1.active.publish (send1)); + ASSERT_EQ (1, votes1->last_votes[nano::test_genesis_key.pub].sequence); + nano::keypair key2; + auto send2 (std::make_shared (genesis.hash (), key2.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + auto vote2 (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 2, send2)); + // Pretend we've waited the timeout + votes1->last_votes[nano::test_genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); + ASSERT_FALSE (node1.active.vote (vote2)); + ASSERT_FALSE (node1.active.publish (send2)); + ASSERT_EQ (2, votes1->last_votes[nano::test_genesis_key.pub].sequence); + // Also resend the old vote, and see if we respect the sequence number + votes1->last_votes[nano::test_genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); + ASSERT_TRUE (node1.active.vote (vote1)); + ASSERT_EQ (2, votes1->last_votes[nano::test_genesis_key.pub].sequence); + ASSERT_EQ (2, votes1->last_votes.size ()); + ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (nano::test_genesis_key.pub)); + ASSERT_EQ (send2->hash (), votes1->last_votes[nano::test_genesis_key.pub].hash); + auto winner (*votes1->tally (transaction).begin ()); + ASSERT_EQ (*send2, *winner.second); +} + +// Lower sequence numbers are ignored +TEST (votes, add_old) +{ + nano::system system (24000, 1); + auto & node1 (*system.nodes[0]); + nano::genesis genesis; + nano::keypair key1; + auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*send1); + auto transaction (node1.store.tx_begin (true)); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); + node1.active.start (send1); + auto votes1 (node1.active.roots.find (send1->root ())->election); + auto vote1 (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 2, send1)); + std::unique_lock lock (node1.active.mutex); + node1.vote_processor.vote_blocking (transaction, vote1, node1.network.endpoint ()); + lock.unlock (); + nano::keypair key2; + auto send2 (std::make_shared (genesis.hash (), key2.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + auto vote2 (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 1, send2)); + votes1->last_votes[nano::test_genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); + lock.lock (); + node1.vote_processor.vote_blocking (transaction, vote2, node1.network.endpoint ()); + lock.unlock (); + ASSERT_EQ (2, votes1->last_votes.size ()); + ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (nano::test_genesis_key.pub)); + ASSERT_EQ (send1->hash (), votes1->last_votes[nano::test_genesis_key.pub].hash); + auto winner (*votes1->tally (transaction).begin ()); + ASSERT_EQ (*send1, *winner.second); +} + +// Lower sequence numbers are accepted for different accounts +TEST (votes, add_old_different_account) +{ + nano::system system (24000, 1); + auto & node1 (*system.nodes[0]); + nano::genesis genesis; + nano::keypair key1; + auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*send1); + auto send2 (std::make_shared (send1->hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*send2); + auto transaction (node1.store.tx_begin (true)); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send2).code); + node1.active.start (send1); + node1.active.start (send2); + auto votes1 (node1.active.roots.find (send1->root ())->election); + auto votes2 (node1.active.roots.find (send2->root ())->election); + ASSERT_EQ (1, votes1->last_votes.size ()); + ASSERT_EQ (1, votes2->last_votes.size ()); + auto vote1 (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 2, send1)); + std::unique_lock lock (node1.active.mutex); + auto vote_result1 (node1.vote_processor.vote_blocking (transaction, vote1, node1.network.endpoint ())); + lock.unlock (); + ASSERT_EQ (nano::vote_code::vote, vote_result1); + ASSERT_EQ (2, votes1->last_votes.size ()); + ASSERT_EQ (1, votes2->last_votes.size ()); + lock.lock (); + auto vote2 (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 1, send2)); + auto vote_result2 (node1.vote_processor.vote_blocking (transaction, vote2, node1.network.endpoint ())); + lock.unlock (); + ASSERT_EQ (nano::vote_code::vote, vote_result2); + ASSERT_EQ (2, votes1->last_votes.size ()); + ASSERT_EQ (2, votes2->last_votes.size ()); + ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (nano::test_genesis_key.pub)); + ASSERT_NE (votes2->last_votes.end (), votes2->last_votes.find (nano::test_genesis_key.pub)); + ASSERT_EQ (send1->hash (), votes1->last_votes[nano::test_genesis_key.pub].hash); + ASSERT_EQ (send2->hash (), votes2->last_votes[nano::test_genesis_key.pub].hash); + auto winner1 (*votes1->tally (transaction).begin ()); + ASSERT_EQ (*send1, *winner1.second); + auto winner2 (*votes2->tally (transaction).begin ()); + ASSERT_EQ (*send2, *winner2.second); +} + +// The voting cooldown is respected +TEST (votes, add_cooldown) +{ + nano::system system (24000, 1); + auto & node1 (*system.nodes[0]); + nano::genesis genesis; + nano::keypair key1; + auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*send1); + auto transaction (node1.store.tx_begin (true)); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); + node1.active.start (send1); + auto votes1 (node1.active.roots.find (send1->root ())->election); + auto vote1 (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 1, send1)); + std::unique_lock lock (node1.active.mutex); + node1.vote_processor.vote_blocking (transaction, vote1, node1.network.endpoint ()); + lock.unlock (); + nano::keypair key2; + auto send2 (std::make_shared (genesis.hash (), key2.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*send2); + auto vote2 (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 2, send2)); + lock.lock (); + node1.vote_processor.vote_blocking (transaction, vote2, node1.network.endpoint ()); + lock.unlock (); + ASSERT_EQ (2, votes1->last_votes.size ()); + ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (nano::test_genesis_key.pub)); + ASSERT_EQ (send1->hash (), votes1->last_votes[nano::test_genesis_key.pub].hash); + auto winner (*votes1->tally (transaction).begin ()); + ASSERT_EQ (*send1, *winner.second); +} + +// Query for block successor +TEST (ledger, successor) +{ + nano::system system (24000, 1); + nano::keypair key1; + nano::genesis genesis; + nano::send_block send1 (genesis.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto transaction (system.nodes[0]->store.tx_begin (true)); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->ledger.process (transaction, send1).code); + ASSERT_EQ (send1, *system.nodes[0]->ledger.successor (transaction, genesis.hash ())); + ASSERT_EQ (*genesis.open, *system.nodes[0]->ledger.successor (transaction, genesis.open->root ())); + ASSERT_EQ (nullptr, system.nodes[0]->ledger.successor (transaction, 0)); +} + +TEST (ledger, fail_change_old) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::change_block block (genesis.hash (), key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result1 (ledger.process (transaction, block)); + ASSERT_EQ (nano::process_result::progress, result1.code); + auto result2 (ledger.process (transaction, block)); + ASSERT_EQ (nano::process_result::old, result2.code); +} + +TEST (ledger, fail_change_gap_previous) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::change_block block (1, key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result1 (ledger.process (transaction, block)); + ASSERT_EQ (nano::process_result::gap_previous, result1.code); +} + +TEST (ledger, fail_change_bad_signature) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::change_block block (genesis.hash (), key1.pub, nano::keypair ().prv, 0, 0); + auto result1 (ledger.process (transaction, block)); + ASSERT_EQ (nano::process_result::bad_signature, result1.code); +} + +TEST (ledger, fail_change_fork) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::change_block block1 (genesis.hash (), key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result1 (ledger.process (transaction, block1)); + ASSERT_EQ (nano::process_result::progress, result1.code); + nano::keypair key2; + nano::change_block block2 (genesis.hash (), key2.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result2 (ledger.process (transaction, block2)); + ASSERT_EQ (nano::process_result::fork, result2.code); +} + +TEST (ledger, fail_send_old) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result1 (ledger.process (transaction, block)); + ASSERT_EQ (nano::process_result::progress, result1.code); + auto result2 (ledger.process (transaction, block)); + ASSERT_EQ (nano::process_result::old, result2.code); +} + +TEST (ledger, fail_send_gap_previous) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block (1, key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result1 (ledger.process (transaction, block)); + ASSERT_EQ (nano::process_result::gap_previous, result1.code); +} + +TEST (ledger, fail_send_bad_signature) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block (genesis.hash (), key1.pub, 1, nano::keypair ().prv, 0, 0); + auto result1 (ledger.process (transaction, block)); + ASSERT_EQ (nano::process_result::bad_signature, result1.code); +} + +TEST (ledger, fail_send_negative_spend) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); + nano::keypair key2; + nano::send_block block2 (block1.hash (), key2.pub, 2, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::negative_spend, ledger.process (transaction, block2).code); +} + +TEST (ledger, fail_send_fork) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); + nano::keypair key2; + nano::send_block block2 (genesis.hash (), key2.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, block2).code); +} + +TEST (ledger, fail_open_old) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); + nano::open_block block2 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); + ASSERT_EQ (nano::process_result::old, ledger.process (transaction, block2).code); +} + +TEST (ledger, fail_open_gap_source) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::open_block block2 (1, 1, key1.pub, key1.prv, key1.pub, 0); + auto result2 (ledger.process (transaction, block2)); + ASSERT_EQ (nano::process_result::gap_source, result2.code); +} + +TEST (ledger, fail_open_bad_signature) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); + nano::open_block block2 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); + block2.signature.clear (); + ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, block2).code); +} + +TEST (ledger, fail_open_fork_previous) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); + nano::send_block block2 (block1.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); + nano::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code); + nano::open_block block4 (block2.hash (), 1, key1.pub, key1.prv, key1.pub, 0); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, block4).code); +} + +TEST (ledger, fail_open_account_mismatch) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); + nano::keypair badkey; + nano::open_block block2 (block1.hash (), 1, badkey.pub, badkey.prv, badkey.pub, 0); + ASSERT_NE (nano::process_result::progress, ledger.process (transaction, block2).code); +} + +TEST (ledger, fail_receive_old) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); + nano::send_block block2 (block1.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); + nano::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code); + nano::receive_block block4 (block3.hash (), block2.hash (), key1.prv, key1.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block4).code); + ASSERT_EQ (nano::process_result::old, ledger.process (transaction, block4).code); +} + +TEST (ledger, fail_receive_gap_source) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result1 (ledger.process (transaction, block1)); + ASSERT_EQ (nano::process_result::progress, result1.code); + nano::send_block block2 (block1.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result2 (ledger.process (transaction, block2)); + ASSERT_EQ (nano::process_result::progress, result2.code); + nano::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); + auto result3 (ledger.process (transaction, block3)); + ASSERT_EQ (nano::process_result::progress, result3.code); + nano::receive_block block4 (block3.hash (), 1, key1.prv, key1.pub, 0); + auto result4 (ledger.process (transaction, block4)); + ASSERT_EQ (nano::process_result::gap_source, result4.code); +} + +TEST (ledger, fail_receive_overreceive) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result1 (ledger.process (transaction, block1)); + ASSERT_EQ (nano::process_result::progress, result1.code); + nano::open_block block2 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); + auto result3 (ledger.process (transaction, block2)); + ASSERT_EQ (nano::process_result::progress, result3.code); + nano::receive_block block3 (block2.hash (), block1.hash (), key1.prv, key1.pub, 0); + auto result4 (ledger.process (transaction, block3)); + ASSERT_EQ (nano::process_result::unreceivable, result4.code); +} + +TEST (ledger, fail_receive_bad_signature) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result1 (ledger.process (transaction, block1)); + ASSERT_EQ (nano::process_result::progress, result1.code); + nano::send_block block2 (block1.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result2 (ledger.process (transaction, block2)); + ASSERT_EQ (nano::process_result::progress, result2.code); + nano::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); + auto result3 (ledger.process (transaction, block3)); + ASSERT_EQ (nano::process_result::progress, result3.code); + nano::receive_block block4 (block3.hash (), block2.hash (), nano::keypair ().prv, 0, 0); + auto result4 (ledger.process (transaction, block4)); + ASSERT_EQ (nano::process_result::bad_signature, result4.code); +} + +TEST (ledger, fail_receive_gap_previous_opened) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result1 (ledger.process (transaction, block1)); + ASSERT_EQ (nano::process_result::progress, result1.code); + nano::send_block block2 (block1.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result2 (ledger.process (transaction, block2)); + ASSERT_EQ (nano::process_result::progress, result2.code); + nano::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); + auto result3 (ledger.process (transaction, block3)); + ASSERT_EQ (nano::process_result::progress, result3.code); + nano::receive_block block4 (1, block2.hash (), key1.prv, key1.pub, 0); + auto result4 (ledger.process (transaction, block4)); + ASSERT_EQ (nano::process_result::gap_previous, result4.code); +} + +TEST (ledger, fail_receive_gap_previous_unopened) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result1 (ledger.process (transaction, block1)); + ASSERT_EQ (nano::process_result::progress, result1.code); + nano::send_block block2 (block1.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result2 (ledger.process (transaction, block2)); + ASSERT_EQ (nano::process_result::progress, result2.code); + nano::receive_block block3 (1, block2.hash (), key1.prv, key1.pub, 0); + auto result3 (ledger.process (transaction, block3)); + ASSERT_EQ (nano::process_result::gap_previous, result3.code); +} + +TEST (ledger, fail_receive_fork_previous) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result1 (ledger.process (transaction, block1)); + ASSERT_EQ (nano::process_result::progress, result1.code); + nano::send_block block2 (block1.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result2 (ledger.process (transaction, block2)); + ASSERT_EQ (nano::process_result::progress, result2.code); + nano::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); + auto result3 (ledger.process (transaction, block3)); + ASSERT_EQ (nano::process_result::progress, result3.code); + nano::keypair key2; + nano::send_block block4 (block3.hash (), key1.pub, 1, key1.prv, key1.pub, 0); + auto result4 (ledger.process (transaction, block4)); + ASSERT_EQ (nano::process_result::progress, result4.code); + nano::receive_block block5 (block3.hash (), block2.hash (), key1.prv, key1.pub, 0); + auto result5 (ledger.process (transaction, block5)); + ASSERT_EQ (nano::process_result::fork, result5.code); +} + +TEST (ledger, fail_receive_received_source) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key1; + nano::send_block block1 (genesis.hash (), key1.pub, 2, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result1 (ledger.process (transaction, block1)); + ASSERT_EQ (nano::process_result::progress, result1.code); + nano::send_block block2 (block1.hash (), key1.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result2 (ledger.process (transaction, block2)); + ASSERT_EQ (nano::process_result::progress, result2.code); + nano::send_block block6 (block2.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto result6 (ledger.process (transaction, block6)); + ASSERT_EQ (nano::process_result::progress, result6.code); + nano::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); + auto result3 (ledger.process (transaction, block3)); + ASSERT_EQ (nano::process_result::progress, result3.code); + nano::keypair key2; + nano::send_block block4 (block3.hash (), key1.pub, 1, key1.prv, key1.pub, 0); + auto result4 (ledger.process (transaction, block4)); + ASSERT_EQ (nano::process_result::progress, result4.code); + nano::receive_block block5 (block4.hash (), block2.hash (), key1.prv, key1.pub, 0); + auto result5 (ledger.process (transaction, block5)); + ASSERT_EQ (nano::process_result::progress, result5.code); + nano::receive_block block7 (block3.hash (), block2.hash (), key1.prv, key1.pub, 0); + auto result7 (ledger.process (transaction, block7)); + ASSERT_EQ (nano::process_result::fork, result7.code); +} + +TEST (ledger, latest_empty) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::keypair key; + auto transaction (store.tx_begin ()); + auto latest (ledger.latest (transaction, key.pub)); + ASSERT_TRUE (latest.is_zero ()); +} + +TEST (ledger, latest_root) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_FALSE (init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key; + ASSERT_EQ (key.pub, ledger.latest_root (transaction, key.pub)); + auto hash1 (ledger.latest (transaction, nano::test_genesis_key.pub)); + nano::send_block send (hash1, 0, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); + ASSERT_EQ (send.hash (), ledger.latest_root (transaction, nano::test_genesis_key.pub)); +} + +TEST (ledger, change_representative_move_representation) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::keypair key1; + auto transaction (store.tx_begin (true)); + nano::genesis genesis; + store.initialize (transaction, genesis); + auto hash1 (genesis.hash ()); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::test_genesis_key.pub)); + nano::send_block send (hash1, key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); + ASSERT_EQ (0, ledger.weight (transaction, nano::test_genesis_key.pub)); + nano::keypair key2; + nano::change_block change (send.hash (), key2.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change).code); + nano::keypair key3; + nano::open_block open (send.hash (), key3.pub, key1.pub, key1.prv, key1.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, key3.pub)); +} + +TEST (ledger, send_open_receive_rollback) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + auto transaction (store.tx_begin (true)); + nano::genesis genesis; + store.initialize (transaction, genesis); + nano::account_info info1; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info1)); + nano::keypair key1; + nano::send_block send1 (info1.head, key1.pub, nano::genesis_amount - 50, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto return1 (ledger.process (transaction, send1)); + ASSERT_EQ (nano::process_result::progress, return1.code); + nano::send_block send2 (send1.hash (), key1.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto return2 (ledger.process (transaction, send2)); + ASSERT_EQ (nano::process_result::progress, return2.code); + nano::keypair key2; + nano::open_block open (send2.hash (), key2.pub, key1.pub, key1.prv, key1.pub, 0); + auto return4 (ledger.process (transaction, open)); + ASSERT_EQ (nano::process_result::progress, return4.code); + nano::receive_block receive (open.hash (), send1.hash (), key1.prv, key1.pub, 0); + auto return5 (ledger.process (transaction, receive)); + ASSERT_EQ (nano::process_result::progress, return5.code); + nano::keypair key3; + ASSERT_EQ (100, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); + nano::change_block change1 (send2.hash (), key3.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + auto return6 (ledger.process (transaction, change1)); + ASSERT_EQ (nano::process_result::progress, return6.code); + ASSERT_EQ (100, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (0, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (transaction, key3.pub)); + ledger.rollback (transaction, receive.hash ()); + ASSERT_EQ (50, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (0, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (transaction, key3.pub)); + ledger.rollback (transaction, open.hash ()); + ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (0, ledger.weight (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (transaction, key3.pub)); + ledger.rollback (transaction, change1.hash ()); + ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (transaction, nano::test_genesis_key.pub)); + ledger.rollback (transaction, send2.hash ()); + ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (transaction, nano::test_genesis_key.pub)); + ledger.rollback (transaction, send1.hash ()); + ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); + ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); + ASSERT_EQ (nano::genesis_amount - 0, ledger.weight (transaction, nano::test_genesis_key.pub)); +} + +TEST (ledger, bootstrap_rep_weight) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::account_info info1; + nano::keypair key2; + nano::genesis genesis; + { + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info1)); + nano::send_block send (info1.head, key2.pub, std::numeric_limits::max () - 50, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ledger.process (transaction, send); + } + { + auto transaction (store.tx_begin ()); + ledger.bootstrap_weight_max_blocks = 3; + ledger.bootstrap_weights[key2.pub] = 1000; + ASSERT_EQ (1000, ledger.weight (transaction, key2.pub)); + } + { + auto transaction (store.tx_begin (true)); + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info1)); + nano::send_block send (info1.head, key2.pub, std::numeric_limits::max () - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ledger.process (transaction, send); + } + { + auto transaction (store.tx_begin ()); + ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); + } +} + +TEST (ledger, block_destination_source) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair dest; + nano::uint128_t balance (nano::genesis_amount); + balance -= nano::Gxrb_ratio; + nano::send_block block1 (genesis.hash (), dest.pub, balance, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + balance -= nano::Gxrb_ratio; + nano::send_block block2 (block1.hash (), nano::genesis_account, balance, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + balance += nano::Gxrb_ratio; + nano::receive_block block3 (block2.hash (), block2.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + balance -= nano::Gxrb_ratio; + nano::state_block block4 (nano::genesis_account, block3.hash (), nano::genesis_account, balance, dest.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + balance -= nano::Gxrb_ratio; + nano::state_block block5 (nano::genesis_account, block4.hash (), nano::genesis_account, balance, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + balance += nano::Gxrb_ratio; + nano::state_block block6 (nano::genesis_account, block5.hash (), nano::genesis_account, balance, block5.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block4).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block5).code); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block6).code); + ASSERT_EQ (balance, ledger.balance (transaction, block6.hash ())); + ASSERT_EQ (dest.pub, ledger.block_destination (transaction, block1)); + ASSERT_TRUE (ledger.block_source (transaction, block1).is_zero ()); + ASSERT_EQ (nano::genesis_account, ledger.block_destination (transaction, block2)); + ASSERT_TRUE (ledger.block_source (transaction, block2).is_zero ()); + ASSERT_TRUE (ledger.block_destination (transaction, block3).is_zero ()); + ASSERT_EQ (block2.hash (), ledger.block_source (transaction, block3)); + ASSERT_EQ (dest.pub, ledger.block_destination (transaction, block4)); + ASSERT_TRUE (ledger.block_source (transaction, block4).is_zero ()); + ASSERT_EQ (nano::genesis_account, ledger.block_destination (transaction, block5)); + ASSERT_TRUE (ledger.block_source (transaction, block5).is_zero ()); + ASSERT_TRUE (ledger.block_destination (transaction, block6).is_zero ()); + ASSERT_EQ (block5.hash (), ledger.block_source (transaction, block6)); +} + +TEST (ledger, state_account) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + ASSERT_EQ (nano::genesis_account, ledger.account (transaction, send1.hash ())); +} + +TEST (ledger, state_send_receive) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); + auto send2 (store.block_get (transaction, send1.hash ())); + ASSERT_NE (nullptr, send2); + ASSERT_EQ (send1, *send2); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + ASSERT_TRUE (store.pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, send1.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); + ASSERT_TRUE (store.block_exists (transaction, receive1.hash ())); + auto receive2 (store.block_get (transaction, receive1.hash ())); + ASSERT_NE (nullptr, receive2); + ASSERT_EQ (receive1, *receive2); + ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, receive1.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); + ASSERT_FALSE (store.pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); +} + +TEST (ledger, state_receive) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); + auto send2 (store.block_get (transaction, send1.hash ())); + ASSERT_NE (nullptr, send2); + ASSERT_EQ (send1, *send2); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, send1.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); + ASSERT_TRUE (store.block_exists (transaction, receive1.hash ())); + auto receive2 (store.block_get (transaction, receive1.hash ())); + ASSERT_NE (nullptr, receive2); + ASSERT_EQ (receive1, *receive2); + ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, receive1.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); +} + +TEST (ledger, state_rep_change) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair rep; + nano::state_block change1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change1).code); + ASSERT_TRUE (store.block_exists (transaction, change1.hash ())); + auto change2 (store.block_get (transaction, change1.hash ())); + ASSERT_NE (nullptr, change2); + ASSERT_EQ (change1, *change2); + ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, change1.hash ())); + ASSERT_EQ (0, ledger.amount (transaction, change1.hash ())); + ASSERT_EQ (0, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, rep.pub)); +} + +TEST (ledger, state_open) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair destination; + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); + auto send2 (store.block_get (transaction, send1.hash ())); + ASSERT_NE (nullptr, send2); + ASSERT_EQ (send1, *send2); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + ASSERT_TRUE (store.pending_exists (transaction, nano::pending_key (destination.pub, send1.hash ()))); + nano::state_block open1 (destination.pub, 0, nano::genesis_account, nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); + ASSERT_FALSE (store.pending_exists (transaction, nano::pending_key (destination.pub, send1.hash ()))); + ASSERT_TRUE (store.block_exists (transaction, open1.hash ())); + auto open2 (store.block_get (transaction, open1.hash ())); + ASSERT_NE (nullptr, open2); + ASSERT_EQ (open1, *open2); + ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1.hash ())); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); +} + +// Make sure old block types can't be inserted after a state block. +TEST (ledger, send_after_state_fail) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::send_block send2 (send1.hash (), nano::genesis_account, nano::genesis_amount - (2 * nano::Gxrb_ratio), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, send2).code); +} + +// Make sure old block types can't be inserted after a state block. +TEST (ledger, receive_after_state_fail) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::receive_block receive1 (send1.hash (), send1.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, receive1).code); +} + +// Make sure old block types can't be inserted after a state block. +TEST (ledger, change_after_state_fail) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::keypair rep; + nano::change_block change1 (send1.hash (), rep.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, change1).code); +} + +TEST (ledger, state_unreceivable_fail) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); + auto send2 (store.block_get (transaction, send1.hash ())); + ASSERT_NE (nullptr, send2); + ASSERT_EQ (send1, *send2); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::gap_source, ledger.process (transaction, receive1).code); +} + +TEST (ledger, state_receive_bad_amount_fail) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); + auto send2 (store.block_get (transaction, send1.hash ())); + ASSERT_NE (nullptr, send2); + ASSERT_EQ (send1, *send2); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, send1.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::balance_mismatch, ledger.process (transaction, receive1).code); +} + +TEST (ledger, state_no_link_amount_fail) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::keypair rep; + nano::state_block change1 (nano::genesis_account, send1.hash (), rep.pub, nano::genesis_amount, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::balance_mismatch, ledger.process (transaction, change1).code); +} + +TEST (ledger, state_receive_wrong_account_fail) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); + auto send2 (store.block_get (transaction, send1.hash ())); + ASSERT_NE (nullptr, send2); + ASSERT_EQ (send1, *send2); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + nano::keypair key; + nano::state_block receive1 (key.pub, 0, nano::genesis_account, nano::Gxrb_ratio, send1.hash (), key.prv, key.pub, 0); + ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, receive1).code); +} + +TEST (ledger, state_open_state_fork) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair destination; + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::state_block open1 (destination.pub, 0, nano::genesis_account, nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); + nano::open_block open2 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, open2).code); + ASSERT_EQ (open1.root (), open2.root ()); +} + +TEST (ledger, state_state_open_fork) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair destination; + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::open_block open1 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); + nano::state_block open2 (destination.pub, 0, nano::genesis_account, nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, open2).code); + ASSERT_EQ (open1.root (), open2.root ()); +} + +TEST (ledger, state_open_previous_fail) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair destination; + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::state_block open1 (destination.pub, destination.pub, nano::genesis_account, nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::gap_previous, ledger.process (transaction, open1).code); +} + +TEST (ledger, state_open_source_fail) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair destination; + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::state_block open1 (destination.pub, 0, nano::genesis_account, 0, 0, destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::gap_source, ledger.process (transaction, open1).code); +} + +TEST (ledger, state_send_change) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair rep; + nano::state_block send1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); + auto send2 (store.block_get (transaction, send1.hash ())); + ASSERT_NE (nullptr, send2); + ASSERT_EQ (send1, *send2); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (0, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, rep.pub)); +} + +TEST (ledger, state_receive_change) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); + auto send2 (store.block_get (transaction, send1.hash ())); + ASSERT_NE (nullptr, send2); + ASSERT_EQ (send1, *send2); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + nano::keypair rep; + nano::state_block receive1 (nano::genesis_account, send1.hash (), rep.pub, nano::genesis_amount, send1.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); + ASSERT_TRUE (store.block_exists (transaction, receive1.hash ())); + auto receive2 (store.block_get (transaction, receive1.hash ())); + ASSERT_NE (nullptr, receive2); + ASSERT_EQ (receive1, *receive2); + ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, receive1.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); + ASSERT_EQ (0, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, rep.pub)); +} + +TEST (ledger, state_open_old) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair destination; + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::open_block open1 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); + ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, open1.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, open1.hash ())); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); +} + +TEST (ledger, state_receive_old) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair destination; + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::state_block send2 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - (2 * nano::Gxrb_ratio), destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); + nano::open_block open1 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); + nano::receive_block receive1 (open1.hash (), send2.hash (), destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); + ASSERT_EQ (2 * nano::Gxrb_ratio, ledger.balance (transaction, receive1.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); +} + +TEST (ledger, state_rollback_send) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); + auto send2 (store.block_get (transaction, send1.hash ())); + ASSERT_NE (nullptr, send2); + ASSERT_EQ (send1, *send2); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + nano::pending_info info; + ASSERT_FALSE (store.pending_get (transaction, nano::pending_key (nano::genesis_account, send1.hash ()), info)); + ASSERT_EQ (nano::genesis_account, info.source); + ASSERT_EQ (nano::Gxrb_ratio, info.amount.number ()); + ledger.rollback (transaction, send1.hash ()); + ASSERT_FALSE (store.block_exists (transaction, send1.hash ())); + ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); + ASSERT_FALSE (store.pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_TRUE (store.block_successor (transaction, genesis.hash ()).is_zero ()); +} + +TEST (ledger, state_rollback_receive) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, send1.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); + ASSERT_FALSE (store.pending_exists (transaction, nano::pending_key (nano::genesis_account, receive1.hash ()))); + ledger.rollback (transaction, receive1.hash ()); + nano::pending_info info; + ASSERT_FALSE (store.pending_get (transaction, nano::pending_key (nano::genesis_account, send1.hash ()), info)); + ASSERT_EQ (nano::genesis_account, info.source); + ASSERT_EQ (nano::Gxrb_ratio, info.amount.number ()); + ASSERT_FALSE (store.block_exists (transaction, receive1.hash ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); +} + +TEST (ledger, state_rollback_received_send) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair key; + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::state_block receive1 (key.pub, 0, key.pub, nano::Gxrb_ratio, send1.hash (), key.prv, key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); + ASSERT_FALSE (store.pending_exists (transaction, nano::pending_key (nano::genesis_account, receive1.hash ()))); + ledger.rollback (transaction, send1.hash ()); + ASSERT_FALSE (store.pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_FALSE (store.block_exists (transaction, send1.hash ())); + ASSERT_FALSE (store.block_exists (transaction, receive1.hash ())); + ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (0, ledger.account_balance (transaction, key.pub)); + ASSERT_EQ (0, ledger.weight (transaction, key.pub)); +} + +TEST (ledger, state_rep_change_rollback) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair rep; + nano::state_block change1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change1).code); + ledger.rollback (transaction, change1.hash ()); + ASSERT_FALSE (store.block_exists (transaction, change1.hash ())); + ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (0, ledger.weight (transaction, rep.pub)); +} + +TEST (ledger, state_open_rollback) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair destination; + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::state_block open1 (destination.pub, 0, nano::genesis_account, nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); + ledger.rollback (transaction, open1.hash ()); + ASSERT_FALSE (store.block_exists (transaction, open1.hash ())); + ASSERT_EQ (0, ledger.account_balance (transaction, destination.pub)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + nano::pending_info info; + ASSERT_FALSE (store.pending_get (transaction, nano::pending_key (destination.pub, send1.hash ()), info)); + ASSERT_EQ (nano::genesis_account, info.source); + ASSERT_EQ (nano::Gxrb_ratio, info.amount.number ()); +} + +TEST (ledger, state_send_change_rollback) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair rep; + nano::state_block send1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + ledger.rollback (transaction, send1.hash ()); + ASSERT_FALSE (store.block_exists (transaction, send1.hash ())); + ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (0, ledger.weight (transaction, rep.pub)); +} + +TEST (ledger, state_receive_change_rollback) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::keypair rep; + nano::state_block receive1 (nano::genesis_account, send1.hash (), rep.pub, nano::genesis_amount, send1.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); + ledger.rollback (transaction, receive1.hash ()); + ASSERT_FALSE (store.block_exists (transaction, receive1.hash ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.account_balance (transaction, nano::genesis_account)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (0, ledger.weight (transaction, rep.pub)); +} + +TEST (ledger, epoch_blocks_general) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::keypair epoch_key; + nano::ledger ledger (store, stats, 123, epoch_key.pub); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair destination; + nano::state_block epoch1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, 123, epoch_key.prv, epoch_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); + nano::state_block epoch2 (nano::genesis_account, epoch1.hash (), nano::genesis_account, nano::genesis_amount, 123, epoch_key.prv, epoch_key.pub, 0); + ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, epoch2).code); + nano::account_info genesis_info; + ASSERT_FALSE (ledger.store.account_get (transaction, nano::genesis_account, genesis_info)); + ASSERT_EQ (genesis_info.epoch, nano::epoch::epoch_1); + ledger.rollback (transaction, epoch1.hash ()); + ASSERT_FALSE (ledger.store.account_get (transaction, nano::genesis_account, genesis_info)); + ASSERT_EQ (genesis_info.epoch, nano::epoch::epoch_0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); + ASSERT_FALSE (ledger.store.account_get (transaction, nano::genesis_account, genesis_info)); + ASSERT_EQ (genesis_info.epoch, nano::epoch::epoch_1); + nano::change_block change1 (epoch1.hash (), nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, change1).code); + nano::state_block send1 (nano::genesis_account, epoch1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::open_block open1 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, open1).code); + nano::state_block epoch3 (destination.pub, 0, nano::genesis_account, 0, 123, epoch_key.prv, epoch_key.pub, 0); + ASSERT_EQ (nano::process_result::representative_mismatch, ledger.process (transaction, epoch3).code); + nano::state_block epoch4 (destination.pub, 0, 0, 0, 123, epoch_key.prv, epoch_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch4).code); + nano::receive_block receive1 (epoch4.hash (), send1.hash (), destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, receive1).code); + nano::state_block receive2 (destination.pub, epoch4.hash (), destination.pub, nano::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive2).code); + ASSERT_EQ (0, ledger.balance (transaction, epoch4.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.balance (transaction, receive2.hash ())); + ASSERT_EQ (nano::Gxrb_ratio, ledger.amount (transaction, receive2.hash ())); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio, ledger.weight (transaction, nano::genesis_account)); + ASSERT_EQ (nano::Gxrb_ratio, ledger.weight (transaction, destination.pub)); +} + +TEST (ledger, epoch_blocks_receive_upgrade) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::keypair epoch_key; + nano::ledger ledger (store, stats, 123, epoch_key.pub); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair destination; + nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::state_block epoch1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, 123, epoch_key.prv, epoch_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); + nano::state_block send2 (nano::genesis_account, epoch1.hash (), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio * 2, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); + nano::open_block open1 (send1.hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); + nano::receive_block receive1 (open1.hash (), send2.hash (), destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, receive1).code); + nano::state_block receive2 (destination.pub, open1.hash (), destination.pub, nano::Gxrb_ratio * 2, send2.hash (), destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive2).code); + nano::account_info destination_info; + ASSERT_FALSE (ledger.store.account_get (transaction, destination.pub, destination_info)); + ASSERT_EQ (destination_info.epoch, nano::epoch::epoch_1); + ledger.rollback (transaction, receive2.hash ()); + ASSERT_FALSE (ledger.store.account_get (transaction, destination.pub, destination_info)); + ASSERT_EQ (destination_info.epoch, nano::epoch::epoch_0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive2).code); + ASSERT_FALSE (ledger.store.account_get (transaction, destination.pub, destination_info)); + ASSERT_EQ (destination_info.epoch, nano::epoch::epoch_1); + nano::keypair destination2; + nano::state_block send3 (destination.pub, receive2.hash (), destination.pub, nano::Gxrb_ratio, destination2.pub, destination.prv, destination.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send3).code); + nano::open_block open2 (send3.hash (), destination2.pub, destination2.pub, destination2.prv, destination2.pub, 0); + ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, open2).code); +} + +TEST (ledger, epoch_blocks_fork) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::keypair epoch_key; + nano::ledger ledger (store, stats, 123, epoch_key.pub); + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair destination; + nano::send_block send1 (genesis.hash (), nano::account (0), nano::genesis_amount, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); + nano::state_block epoch1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, 123, epoch_key.prv, epoch_key.pub, 0); + ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, epoch1).code); +} + +TEST (ledger, could_fit) +{ + bool init (false); + nano::mdb_store store (init, nano::unique_path ()); + ASSERT_TRUE (!init); + nano::stat stats; + nano::keypair epoch_key; + nano::ledger ledger (store, stats, 123, epoch_key.pub); + nano::keypair epoch_signer; + ledger.epoch_link = 123; + ledger.epoch_signer = epoch_signer.pub; + nano::genesis genesis; + auto transaction (store.tx_begin (true)); + store.initialize (transaction, genesis); + nano::keypair destination; + // Test legacy and state change blocks could_fit + nano::change_block change1 (genesis.hash (), nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::state_block change2 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_TRUE (ledger.could_fit (transaction, change1)); + ASSERT_TRUE (ledger.could_fit (transaction, change2)); + // Test legacy and state send + nano::keypair key1; + nano::send_block send1 (change1.hash (), key1.pub, nano::genesis_amount - 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::state_block send2 (nano::genesis_account, change1.hash (), nano::genesis_account, nano::genesis_amount - 1, key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_FALSE (ledger.could_fit (transaction, send1)); + ASSERT_FALSE (ledger.could_fit (transaction, send2)); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change1).code); + ASSERT_TRUE (ledger.could_fit (transaction, change1)); + ASSERT_TRUE (ledger.could_fit (transaction, change2)); + ASSERT_TRUE (ledger.could_fit (transaction, send1)); + ASSERT_TRUE (ledger.could_fit (transaction, send2)); + // Test legacy and state open + nano::open_block open1 (send2.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, 0); + nano::state_block open2 (key1.pub, 0, nano::genesis_account, 1, send2.hash (), key1.prv, key1.pub, 0); + ASSERT_FALSE (ledger.could_fit (transaction, open1)); + ASSERT_FALSE (ledger.could_fit (transaction, open2)); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); + ASSERT_TRUE (ledger.could_fit (transaction, send1)); + ASSERT_TRUE (ledger.could_fit (transaction, send2)); + ASSERT_TRUE (ledger.could_fit (transaction, open1)); + ASSERT_TRUE (ledger.could_fit (transaction, open2)); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); + ASSERT_TRUE (ledger.could_fit (transaction, open1)); + ASSERT_TRUE (ledger.could_fit (transaction, open2)); + // Create another send to receive + nano::state_block send3 (nano::genesis_account, send2.hash (), nano::genesis_account, nano::genesis_amount - 2, key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + // Test legacy and state receive + nano::receive_block receive1 (open1.hash (), send3.hash (), key1.prv, key1.pub, 0); + nano::state_block receive2 (key1.pub, open1.hash (), nano::genesis_account, 2, send3.hash (), key1.prv, key1.pub, 0); + ASSERT_FALSE (ledger.could_fit (transaction, receive1)); + ASSERT_FALSE (ledger.could_fit (transaction, receive2)); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send3).code); + ASSERT_TRUE (ledger.could_fit (transaction, receive1)); + ASSERT_TRUE (ledger.could_fit (transaction, receive2)); + // Test epoch (state) + nano::state_block epoch1 (key1.pub, receive1.hash (), nano::genesis_account, 2, ledger.epoch_link, epoch_signer.prv, epoch_signer.pub, 0); + ASSERT_FALSE (ledger.could_fit (transaction, epoch1)); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); + ASSERT_TRUE (ledger.could_fit (transaction, receive1)); + ASSERT_TRUE (ledger.could_fit (transaction, receive2)); + ASSERT_TRUE (ledger.could_fit (transaction, epoch1)); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); + ASSERT_TRUE (ledger.could_fit (transaction, epoch1)); +} diff --git a/nano/core_test/message.cpp b/nano/core_test/message.cpp new file mode 100644 index 00000000..85c18fcc --- /dev/null +++ b/nano/core_test/message.cpp @@ -0,0 +1,85 @@ +#include + +#include + +TEST (message, keepalive_serialization) +{ + nano::keepalive request1; + std::vector bytes; + { + nano::vectorstream stream (bytes); + request1.serialize (stream); + } + auto error (false); + nano::bufferstream stream (bytes.data (), bytes.size ()); + nano::message_header header (error, stream); + ASSERT_FALSE (error); + nano::keepalive request2 (error, stream, header); + ASSERT_FALSE (error); + ASSERT_EQ (request1, request2); +} + +TEST (message, keepalive_deserialize) +{ + nano::keepalive message1; + message1.peers[0] = nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000); + std::vector bytes; + { + nano::vectorstream stream (bytes); + message1.serialize (stream); + } + nano::bufferstream stream (bytes.data (), bytes.size ()); + auto error (false); + nano::message_header header (error, stream); + ASSERT_FALSE (error); + ASSERT_EQ (nano::message_type::keepalive, header.type); + nano::keepalive message2 (error, stream, header); + ASSERT_FALSE (error); + ASSERT_EQ (message1.peers, message2.peers); +} + +TEST (message, publish_serialization) +{ + nano::publish publish (std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5)); + ASSERT_EQ (nano::block_type::send, publish.header.block_type ()); + std::vector bytes; + { + nano::vectorstream stream (bytes); + publish.header.serialize (stream); + } + ASSERT_EQ (8, bytes.size ()); + ASSERT_EQ (0x52, bytes[0]); + ASSERT_EQ (0x41, bytes[1]); + ASSERT_EQ (nano::protocol_version, bytes[2]); + ASSERT_EQ (nano::protocol_version, bytes[3]); + ASSERT_EQ (nano::protocol_version_min, bytes[4]); + ASSERT_EQ (static_cast (nano::message_type::publish), bytes[5]); + ASSERT_EQ (0x00, bytes[6]); // extensions + ASSERT_EQ (static_cast (nano::block_type::send), bytes[7]); + nano::bufferstream stream (bytes.data (), bytes.size ()); + auto error (false); + nano::message_header header (error, stream); + ASSERT_FALSE (error); + ASSERT_EQ (nano::protocol_version_min, header.version_min); + ASSERT_EQ (nano::protocol_version, header.version_using); + ASSERT_EQ (nano::protocol_version, header.version_max); + ASSERT_EQ (nano::message_type::publish, header.type); +} + +TEST (message, confirm_ack_serialization) +{ + nano::keypair key1; + auto vote (std::make_shared (key1.pub, key1.prv, 0, std::make_shared (0, 1, 2, key1.prv, 4, 5))); + nano::confirm_ack con1 (vote); + std::vector bytes; + { + nano::vectorstream stream1 (bytes); + con1.serialize (stream1); + } + nano::bufferstream stream2 (bytes.data (), bytes.size ()); + bool error (false); + nano::message_header header (error, stream2); + nano::confirm_ack con2 (error, stream2, header); + ASSERT_FALSE (error); + ASSERT_EQ (con1, con2); +} diff --git a/nano/core_test/message_parser.cpp b/nano/core_test/message_parser.cpp new file mode 100644 index 00000000..5b00a651 --- /dev/null +++ b/nano/core_test/message_parser.cpp @@ -0,0 +1,200 @@ +#include +#include + +namespace +{ +class test_visitor : public nano::message_visitor +{ +public: + test_visitor () : + keepalive_count (0), + publish_count (0), + confirm_req_count (0), + confirm_ack_count (0), + bulk_pull_count (0), + bulk_pull_account_count (0), + bulk_pull_blocks_count (0), + bulk_push_count (0), + frontier_req_count (0) + { + } + void keepalive (nano::keepalive const &) override + { + ++keepalive_count; + } + void publish (nano::publish const &) override + { + ++publish_count; + } + void confirm_req (nano::confirm_req const &) override + { + ++confirm_req_count; + } + void confirm_ack (nano::confirm_ack const &) override + { + ++confirm_ack_count; + } + void bulk_pull (nano::bulk_pull const &) override + { + ++bulk_pull_count; + } + void bulk_pull_account (nano::bulk_pull_account const &) override + { + ++bulk_pull_account_count; + } + void bulk_pull_blocks (nano::bulk_pull_blocks const &) override + { + ++bulk_pull_blocks_count; + } + void bulk_push (nano::bulk_push const &) override + { + ++bulk_push_count; + } + void frontier_req (nano::frontier_req const &) override + { + ++frontier_req_count; + } + void node_id_handshake (nano::node_id_handshake const &) override + { + ++node_id_handshake_count; + } + uint64_t keepalive_count; + uint64_t publish_count; + uint64_t confirm_req_count; + uint64_t confirm_ack_count; + uint64_t bulk_pull_count; + uint64_t bulk_pull_account_count; + uint64_t bulk_pull_blocks_count; + uint64_t bulk_push_count; + uint64_t frontier_req_count; + uint64_t node_id_handshake_count; +}; +} + +TEST (message_parser, exact_confirm_ack_size) +{ + nano::system system (24000, 1); + test_visitor visitor; + nano::block_uniquer block_uniquer; + nano::vote_uniquer vote_uniquer (block_uniquer); + nano::message_parser parser (block_uniquer, vote_uniquer, visitor, system.work); + auto block (std::make_shared (1, 1, 2, nano::keypair ().prv, 4, system.work.generate (1))); + auto vote (std::make_shared (0, nano::keypair ().prv, 0, std::move (block))); + nano::confirm_ack message (vote); + std::vector bytes; + { + nano::vectorstream stream (bytes); + message.serialize (stream); + } + ASSERT_EQ (0, visitor.confirm_ack_count); + ASSERT_EQ (parser.status, nano::message_parser::parse_status::success); + auto error (false); + nano::bufferstream stream1 (bytes.data (), bytes.size ()); + nano::message_header header1 (error, stream1); + ASSERT_FALSE (error); + parser.deserialize_confirm_ack (stream1, header1); + ASSERT_EQ (1, visitor.confirm_ack_count); + ASSERT_EQ (parser.status, nano::message_parser::parse_status::success); + bytes.push_back (0); + nano::bufferstream stream2 (bytes.data (), bytes.size ()); + nano::message_header header2 (error, stream2); + ASSERT_FALSE (error); + parser.deserialize_confirm_ack (stream2, header2); + ASSERT_EQ (1, visitor.confirm_ack_count); + ASSERT_NE (parser.status, nano::message_parser::parse_status::success); +} + +TEST (message_parser, exact_confirm_req_size) +{ + nano::system system (24000, 1); + test_visitor visitor; + nano::block_uniquer block_uniquer; + nano::vote_uniquer vote_uniquer (block_uniquer); + nano::message_parser parser (block_uniquer, vote_uniquer, visitor, system.work); + auto block (std::make_shared (1, 1, 2, nano::keypair ().prv, 4, system.work.generate (1))); + nano::confirm_req message (std::move (block)); + std::vector bytes; + { + nano::vectorstream stream (bytes); + message.serialize (stream); + } + ASSERT_EQ (0, visitor.confirm_req_count); + ASSERT_EQ (parser.status, nano::message_parser::parse_status::success); + auto error (false); + nano::bufferstream stream1 (bytes.data (), bytes.size ()); + nano::message_header header1 (error, stream1); + ASSERT_FALSE (error); + parser.deserialize_confirm_req (stream1, header1); + ASSERT_EQ (1, visitor.confirm_req_count); + ASSERT_EQ (parser.status, nano::message_parser::parse_status::success); + bytes.push_back (0); + nano::bufferstream stream2 (bytes.data (), bytes.size ()); + nano::message_header header2 (error, stream2); + ASSERT_FALSE (error); + parser.deserialize_confirm_req (stream2, header2); + ASSERT_EQ (1, visitor.confirm_req_count); + ASSERT_NE (parser.status, nano::message_parser::parse_status::success); +} + +TEST (message_parser, exact_publish_size) +{ + nano::system system (24000, 1); + test_visitor visitor; + nano::block_uniquer block_uniquer; + nano::vote_uniquer vote_uniquer (block_uniquer); + nano::message_parser parser (block_uniquer, vote_uniquer, visitor, system.work); + auto block (std::make_shared (1, 1, 2, nano::keypair ().prv, 4, system.work.generate (1))); + nano::publish message (std::move (block)); + std::vector bytes; + { + nano::vectorstream stream (bytes); + message.serialize (stream); + } + ASSERT_EQ (0, visitor.publish_count); + ASSERT_EQ (parser.status, nano::message_parser::parse_status::success); + auto error (false); + nano::bufferstream stream1 (bytes.data (), bytes.size ()); + nano::message_header header1 (error, stream1); + ASSERT_FALSE (error); + parser.deserialize_publish (stream1, header1); + ASSERT_EQ (1, visitor.publish_count); + ASSERT_EQ (parser.status, nano::message_parser::parse_status::success); + bytes.push_back (0); + nano::bufferstream stream2 (bytes.data (), bytes.size ()); + nano::message_header header2 (error, stream2); + ASSERT_FALSE (error); + parser.deserialize_publish (stream2, header2); + ASSERT_EQ (1, visitor.publish_count); + ASSERT_NE (parser.status, nano::message_parser::parse_status::success); +} + +TEST (message_parser, exact_keepalive_size) +{ + nano::system system (24000, 1); + test_visitor visitor; + nano::block_uniquer block_uniquer; + nano::vote_uniquer vote_uniquer (block_uniquer); + nano::message_parser parser (block_uniquer, vote_uniquer, visitor, system.work); + nano::keepalive message; + std::vector bytes; + { + nano::vectorstream stream (bytes); + message.serialize (stream); + } + ASSERT_EQ (0, visitor.keepalive_count); + ASSERT_EQ (parser.status, nano::message_parser::parse_status::success); + auto error (false); + nano::bufferstream stream1 (bytes.data (), bytes.size ()); + nano::message_header header1 (error, stream1); + ASSERT_FALSE (error); + parser.deserialize_keepalive (stream1, header1); + ASSERT_EQ (1, visitor.keepalive_count); + ASSERT_EQ (parser.status, nano::message_parser::parse_status::success); + bytes.push_back (0); + nano::bufferstream stream2 (bytes.data (), bytes.size ()); + nano::message_header header2 (error, stream2); + ASSERT_FALSE (error); + parser.deserialize_keepalive (stream2, header2); + ASSERT_EQ (1, visitor.keepalive_count); + ASSERT_NE (parser.status, nano::message_parser::parse_status::success); +} diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp new file mode 100644 index 00000000..7fafdf96 --- /dev/null +++ b/nano/core_test/network.cpp @@ -0,0 +1,1275 @@ +#include +#include +#include +#include + +using namespace std::chrono_literals; + +TEST (network, tcp_connection) +{ + boost::asio::io_context io_ctx; + boost::asio::ip::tcp::acceptor acceptor (io_ctx); + boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v4::any (), 24000); + acceptor.open (endpoint.protocol ()); + acceptor.set_option (boost::asio::ip::tcp::acceptor::reuse_address (true)); + acceptor.bind (endpoint); + acceptor.listen (); + boost::asio::ip::tcp::socket incoming (io_ctx); + auto done1 (false); + std::string message1; + acceptor.async_accept (incoming, + [&done1, &message1](boost::system::error_code const & ec_a) { + if (ec_a) + { + message1 = ec_a.message (); + std::cerr << message1; + } + done1 = true; }); + boost::asio::ip::tcp::socket connector (io_ctx); + auto done2 (false); + std::string message2; + connector.async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), 24000), + [&done2, &message2](boost::system::error_code const & ec_a) { + if (ec_a) + { + message2 = ec_a.message (); + std::cerr << message2; + } + done2 = true; + }); + while (!done1 || !done2) + { + io_ctx.poll (); + } + ASSERT_EQ (0, message1.size ()); + ASSERT_EQ (0, message2.size ()); +} + +TEST (network, construction) +{ + nano::system system (24000, 1); + ASSERT_EQ (1, system.nodes.size ()); + ASSERT_EQ (24000, system.nodes[0]->network.socket.local_endpoint ().port ()); +} + +TEST (network, self_discard) +{ + nano::system system (24000, 1); + nano::udp_data data; + data.endpoint = system.nodes[0]->network.endpoint (); + ASSERT_EQ (0, system.nodes[0]->stats.count (nano::stat::type::error, nano::stat::detail::bad_sender)); + system.nodes[0]->network.receive_action (&data); + ASSERT_EQ (1, system.nodes[0]->stats.count (nano::stat::type::error, nano::stat::detail::bad_sender)); +} + +TEST (network, send_node_id_handshake) +{ + nano::system system (24000, 1); + auto list1 (system.nodes[0]->peers.list ()); + ASSERT_EQ (0, list1.size ()); + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + node1->start (); + system.nodes.push_back (node1); + auto initial (system.nodes[0]->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in)); + auto initial_node1 (node1->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in)); + system.nodes[0]->network.send_keepalive (node1->network.endpoint ()); + ASSERT_EQ (0, system.nodes[0]->peers.list ().size ()); + ASSERT_EQ (0, node1->peers.list ().size ()); + system.deadline_set (10s); + while (node1->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in) == initial_node1) + { + ASSERT_NO_ERROR (system.poll ()); + } + ASSERT_EQ (0, system.nodes[0]->peers.list ().size ()); + ASSERT_EQ (1, node1->peers.list ().size ()); + system.deadline_set (10s); + while (system.nodes[0]->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in) < initial + 2) + { + ASSERT_NO_ERROR (system.poll ()); + } + auto peers1 (system.nodes[0]->peers.list ()); + auto peers2 (node1->peers.list ()); + ASSERT_EQ (1, peers1.size ()); + ASSERT_EQ (1, peers2.size ()); + ASSERT_EQ (node1->network.endpoint (), peers1[0]); + ASSERT_EQ (system.nodes[0]->network.endpoint (), peers2[0]); + node1->stop (); +} + +TEST (network, keepalive_ipv4) +{ + nano::system system (24000, 1); + auto list1 (system.nodes[0]->peers.list ()); + ASSERT_EQ (0, list1.size ()); + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + node1->start (); + system.nodes.push_back (node1); + node1->send_keepalive (nano::endpoint (boost::asio::ip::address_v4::loopback (), 24000)); + auto initial (system.nodes[0]->stats.count (nano::stat::type::message, nano::stat::detail::keepalive, nano::stat::dir::in)); + system.deadline_set (10s); + while (system.nodes[0]->stats.count (nano::stat::type::message, nano::stat::detail::keepalive, nano::stat::dir::in) == initial) + { + ASSERT_NO_ERROR (system.poll ()); + } + node1->stop (); +} + +TEST (network, multi_keepalive) +{ + nano::system system (24000, 1); + auto list1 (system.nodes[0]->peers.list ()); + ASSERT_EQ (0, list1.size ()); + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (init1.error ()); + node1->start (); + system.nodes.push_back (node1); + ASSERT_EQ (0, node1->peers.size ()); + node1->network.send_keepalive (system.nodes[0]->network.endpoint ()); + ASSERT_EQ (0, node1->peers.size ()); + ASSERT_EQ (0, system.nodes[0]->peers.size ()); + system.deadline_set (10s); + while (system.nodes[0]->peers.size () != 1) + { + ASSERT_NO_ERROR (system.poll ()); + } + nano::node_init init2; + auto node2 (std::make_shared (init2, system.io_ctx, 24002, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (init2.error ()); + node2->start (); + system.nodes.push_back (node2); + node2->network.send_keepalive (system.nodes[0]->network.endpoint ()); + system.deadline_set (10s); + while (node1->peers.size () != 2 || system.nodes[0]->peers.size () != 2 || node2->peers.size () != 2) + { + ASSERT_NO_ERROR (system.poll ()); + } + node1->stop (); + node2->stop (); +} + +TEST (network, send_discarded_publish) +{ + nano::system system (24000, 2); + auto block (std::make_shared (1, 1, 2, nano::keypair ().prv, 4, system.work.generate (1))); + nano::genesis genesis; + { + auto transaction (system.nodes[0]->store.tx_begin ()); + system.nodes[0]->network.republish_block (block); + ASSERT_EQ (genesis.hash (), system.nodes[0]->ledger.latest (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (genesis.hash (), system.nodes[1]->latest (nano::test_genesis_key.pub)); + } + system.deadline_set (10s); + while (system.nodes[1]->stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) == 0) + { + ASSERT_NO_ERROR (system.poll ()); + } + auto transaction (system.nodes[0]->store.tx_begin ()); + ASSERT_EQ (genesis.hash (), system.nodes[0]->ledger.latest (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (genesis.hash (), system.nodes[1]->latest (nano::test_genesis_key.pub)); +} + +TEST (network, send_invalid_publish) +{ + nano::system system (24000, 2); + nano::genesis genesis; + auto block (std::make_shared (1, 1, 20, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (1))); + { + auto transaction (system.nodes[0]->store.tx_begin ()); + system.nodes[0]->network.republish_block (block); + ASSERT_EQ (genesis.hash (), system.nodes[0]->ledger.latest (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (genesis.hash (), system.nodes[1]->latest (nano::test_genesis_key.pub)); + } + system.deadline_set (10s); + while (system.nodes[1]->stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) == 0) + { + ASSERT_NO_ERROR (system.poll ()); + } + auto transaction (system.nodes[0]->store.tx_begin ()); + ASSERT_EQ (genesis.hash (), system.nodes[0]->ledger.latest (transaction, nano::test_genesis_key.pub)); + ASSERT_EQ (genesis.hash (), system.nodes[1]->latest (nano::test_genesis_key.pub)); +} + +TEST (network, send_valid_confirm_ack) +{ + nano::system system (24000, 2); + nano::keypair key2; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + system.wallet (1)->insert_adhoc (key2.prv); + nano::block_hash latest1 (system.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::send_block block2 (latest1, key2.pub, 50, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (latest1)); + nano::block_hash latest2 (system.nodes[1]->latest (nano::test_genesis_key.pub)); + system.nodes[0]->process_active (std::make_shared (block2)); + system.deadline_set (10s); + // Keep polling until latest block changes + while (system.nodes[1]->latest (nano::test_genesis_key.pub) == latest2) + { + ASSERT_NO_ERROR (system.poll ()); + } + // Make sure the balance has decreased after processing the block. + ASSERT_EQ (50, system.nodes[1]->balance (nano::test_genesis_key.pub)); +} + +TEST (network, send_valid_publish) +{ + nano::system system (24000, 2); + system.nodes[0]->bootstrap_initiator.stop (); + system.nodes[1]->bootstrap_initiator.stop (); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key2; + system.wallet (1)->insert_adhoc (key2.prv); + nano::block_hash latest1 (system.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::send_block block2 (latest1, key2.pub, 50, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (latest1)); + auto hash2 (block2.hash ()); + nano::block_hash latest2 (system.nodes[1]->latest (nano::test_genesis_key.pub)); + system.nodes[1]->process_active (std::make_shared (block2)); + system.deadline_set (10s); + while (system.nodes[0]->stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) == 0) + { + ASSERT_NO_ERROR (system.poll ()); + } + ASSERT_NE (hash2, latest2); + system.deadline_set (10s); + while (system.nodes[1]->latest (nano::test_genesis_key.pub) == latest2) + { + ASSERT_NO_ERROR (system.poll ()); + } + ASSERT_EQ (50, system.nodes[1]->balance (nano::test_genesis_key.pub)); +} + +TEST (network, send_insufficient_work) +{ + nano::system system (24000, 2); + auto block (std::make_shared (0, 1, 20, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + nano::publish publish (std::move (block)); + std::shared_ptr> bytes (new std::vector); + { + nano::vectorstream stream (*bytes); + publish.serialize (stream); + } + auto node1 (system.nodes[1]->shared ()); + system.nodes[0]->network.send_buffer (bytes->data (), bytes->size (), system.nodes[1]->network.endpoint (), [bytes, node1](boost::system::error_code const & ec, size_t size) {}); + ASSERT_EQ (0, system.nodes[0]->stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); + system.deadline_set (10s); + while (system.nodes[1]->stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) == 0) + { + ASSERT_NO_ERROR (system.poll ()); + } + ASSERT_EQ (1, system.nodes[1]->stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); +} + +TEST (receivable_processor, confirm_insufficient_pos) +{ + nano::system system (24000, 1); + auto & node1 (*system.nodes[0]); + nano::genesis genesis; + auto block1 (std::make_shared (genesis.hash (), 0, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*block1); + ASSERT_EQ (nano::process_result::progress, node1.process (*block1).code); + auto node_l (system.nodes[0]); + node1.active.start (block1); + nano::keypair key1; + auto vote (std::make_shared (key1.pub, key1.prv, 0, block1)); + nano::confirm_ack con1 (vote); + node1.process_message (con1, node1.network.endpoint ()); +} + +TEST (receivable_processor, confirm_sufficient_pos) +{ + nano::system system (24000, 1); + auto & node1 (*system.nodes[0]); + nano::genesis genesis; + auto block1 (std::make_shared (genesis.hash (), 0, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node1.work_generate_blocking (*block1); + ASSERT_EQ (nano::process_result::progress, node1.process (*block1).code); + auto node_l (system.nodes[0]); + node1.active.start (block1); + auto vote (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 0, block1)); + nano::confirm_ack con1 (vote); + node1.process_message (con1, node1.network.endpoint ()); +} + +TEST (receivable_processor, send_with_receive) +{ + auto amount (std::numeric_limits::max ()); + nano::system system (24000, 2); + nano::keypair key2; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::block_hash latest1 (system.nodes[0]->latest (nano::test_genesis_key.pub)); + system.wallet (1)->insert_adhoc (key2.prv); + auto block1 (std::make_shared (latest1, key2.pub, amount - system.nodes[0]->config.receive_minimum.number (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (latest1))); + ASSERT_EQ (amount, system.nodes[0]->balance (nano::test_genesis_key.pub)); + ASSERT_EQ (0, system.nodes[0]->balance (key2.pub)); + ASSERT_EQ (amount, system.nodes[1]->balance (nano::test_genesis_key.pub)); + ASSERT_EQ (0, system.nodes[1]->balance (key2.pub)); + system.nodes[0]->process_active (block1); + system.nodes[0]->block_processor.flush (); + system.nodes[1]->process_active (block1); + system.nodes[1]->block_processor.flush (); + ASSERT_EQ (amount - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (nano::test_genesis_key.pub)); + ASSERT_EQ (0, system.nodes[0]->balance (key2.pub)); + ASSERT_EQ (amount - system.nodes[0]->config.receive_minimum.number (), system.nodes[1]->balance (nano::test_genesis_key.pub)); + ASSERT_EQ (0, system.nodes[1]->balance (key2.pub)); + system.deadline_set (10s); + while (system.nodes[0]->balance (key2.pub) != system.nodes[0]->config.receive_minimum.number ()) + { + ASSERT_NO_ERROR (system.poll ()); + } + ASSERT_EQ (amount - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (nano::test_genesis_key.pub)); + ASSERT_EQ (system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (key2.pub)); + ASSERT_EQ (amount - system.nodes[0]->config.receive_minimum.number (), system.nodes[1]->balance (nano::test_genesis_key.pub)); + ASSERT_EQ (system.nodes[0]->config.receive_minimum.number (), system.nodes[1]->balance (key2.pub)); +} + +TEST (network, receive_weight_change) +{ + nano::system system (24000, 2); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key2; + system.wallet (1)->insert_adhoc (key2.prv); + { + auto transaction (system.nodes[1]->store.tx_begin (true)); + system.wallet (1)->store.representative_set (transaction, key2.pub); + } + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + system.deadline_set (10s); + while (std::any_of (system.nodes.begin (), system.nodes.end (), [&](std::shared_ptr const & node_a) { return node_a->weight (key2.pub) != system.nodes[0]->config.receive_minimum.number (); })) + { + ASSERT_NO_ERROR (system.poll ()); + } +} + +TEST (parse_endpoint, valid) +{ + std::string string ("::1:24000"); + nano::endpoint endpoint; + ASSERT_FALSE (nano::parse_endpoint (string, endpoint)); + ASSERT_EQ (boost::asio::ip::address_v6::loopback (), endpoint.address ()); + ASSERT_EQ (24000, endpoint.port ()); +} + +TEST (parse_endpoint, invalid_port) +{ + std::string string ("::1:24a00"); + nano::endpoint endpoint; + ASSERT_TRUE (nano::parse_endpoint (string, endpoint)); +} + +TEST (parse_endpoint, invalid_address) +{ + std::string string ("::q:24000"); + nano::endpoint endpoint; + ASSERT_TRUE (nano::parse_endpoint (string, endpoint)); +} + +TEST (parse_endpoint, no_address) +{ + std::string string (":24000"); + nano::endpoint endpoint; + ASSERT_TRUE (nano::parse_endpoint (string, endpoint)); +} + +TEST (parse_endpoint, no_port) +{ + std::string string ("::1:"); + nano::endpoint endpoint; + ASSERT_TRUE (nano::parse_endpoint (string, endpoint)); +} + +TEST (parse_endpoint, no_colon) +{ + std::string string ("::1"); + nano::endpoint endpoint; + ASSERT_TRUE (nano::parse_endpoint (string, endpoint)); +} + +// If the account doesn't exist, current == end so there's no iteration +TEST (bulk_pull, no_address) +{ + nano::system system (24000, 1); + auto connection (std::make_shared (nullptr, system.nodes[0])); + std::unique_ptr req (new nano::bulk_pull); + req->start = 1; + req->end = 2; + connection->requests.push (std::unique_ptr{}); + auto request (std::make_shared (connection, std::move (req))); + ASSERT_EQ (request->current, request->request->end); + ASSERT_TRUE (request->current.is_zero ()); +} + +TEST (bulk_pull, genesis_to_end) +{ + nano::system system (24000, 1); + auto connection (std::make_shared (nullptr, system.nodes[0])); + std::unique_ptr req (new nano::bulk_pull{}); + req->start = nano::test_genesis_key.pub; + req->end.clear (); + connection->requests.push (std::unique_ptr{}); + auto request (std::make_shared (connection, std::move (req))); + ASSERT_EQ (system.nodes[0]->latest (nano::test_genesis_key.pub), request->current); + ASSERT_EQ (request->request->end, request->request->end); +} + +// If we can't find the end block, send everything +TEST (bulk_pull, no_end) +{ + nano::system system (24000, 1); + auto connection (std::make_shared (nullptr, system.nodes[0])); + std::unique_ptr req (new nano::bulk_pull{}); + req->start = nano::test_genesis_key.pub; + req->end = 1; + connection->requests.push (std::unique_ptr{}); + auto request (std::make_shared (connection, std::move (req))); + ASSERT_EQ (system.nodes[0]->latest (nano::test_genesis_key.pub), request->current); + ASSERT_TRUE (request->request->end.is_zero ()); +} + +TEST (bulk_pull, end_not_owned) +{ + nano::system system (24000, 1); + nano::keypair key2; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, 100)); + nano::block_hash latest (system.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::open_block open (0, 1, 2, nano::keypair ().prv, 4, 5); + open.hashables.account = key2.pub; + open.hashables.representative = key2.pub; + open.hashables.source = latest; + open.signature = nano::sign_message (key2.prv, key2.pub, open.hash ()); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code); + auto connection (std::make_shared (nullptr, system.nodes[0])); + nano::genesis genesis; + std::unique_ptr req (new nano::bulk_pull{}); + req->start = key2.pub; + req->end = genesis.hash (); + connection->requests.push (std::unique_ptr{}); + auto request (std::make_shared (connection, std::move (req))); + ASSERT_EQ (request->current, request->request->end); +} + +TEST (bulk_pull, none) +{ + nano::system system (24000, 1); + auto connection (std::make_shared (nullptr, system.nodes[0])); + nano::genesis genesis; + std::unique_ptr req (new nano::bulk_pull{}); + req->start = nano::test_genesis_key.pub; + req->end = genesis.hash (); + connection->requests.push (std::unique_ptr{}); + auto request (std::make_shared (connection, std::move (req))); + auto block (request->get_next ()); + ASSERT_EQ (nullptr, block); +} + +TEST (bulk_pull, get_next_on_open) +{ + nano::system system (24000, 1); + auto connection (std::make_shared (nullptr, system.nodes[0])); + std::unique_ptr req (new nano::bulk_pull{}); + req->start = nano::test_genesis_key.pub; + req->end.clear (); + connection->requests.push (std::unique_ptr{}); + auto request (std::make_shared (connection, std::move (req))); + auto block (request->get_next ()); + ASSERT_NE (nullptr, block); + ASSERT_TRUE (block->previous ().is_zero ()); + ASSERT_FALSE (connection->requests.empty ()); + ASSERT_EQ (request->current, request->request->end); +} + +TEST (bulk_pull, by_block) +{ + nano::system system (24000, 1); + auto connection (std::make_shared (nullptr, system.nodes[0])); + nano::genesis genesis; + std::unique_ptr req (new nano::bulk_pull{}); + req->start = genesis.hash (); + req->end.clear (); + connection->requests.push (std::unique_ptr{}); + auto request (std::make_shared (connection, std::move (req))); + auto block (request->get_next ()); + ASSERT_NE (nullptr, block); + ASSERT_EQ (block->hash (), genesis.hash ()); + + block = request->get_next (); + ASSERT_EQ (nullptr, block); +} + +TEST (bulk_pull, by_block_single) +{ + nano::system system (24000, 1); + auto connection (std::make_shared (nullptr, system.nodes[0])); + nano::genesis genesis; + std::unique_ptr req (new nano::bulk_pull{}); + req->start = genesis.hash (); + req->end = genesis.hash (); + connection->requests.push (std::unique_ptr{}); + auto request (std::make_shared (connection, std::move (req))); + auto block (request->get_next ()); + ASSERT_NE (nullptr, block); + ASSERT_EQ (block->hash (), genesis.hash ()); + + block = request->get_next (); + ASSERT_EQ (nullptr, block); +} + +TEST (bulk_pull, count_limit) +{ + nano::system system (24000, 1); + nano::genesis genesis; + + auto send1 (std::make_shared (system.nodes[0]->latest (nano::test_genesis_key.pub), nano::test_genesis_key.pub, 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (system.nodes[0]->latest (nano::test_genesis_key.pub)))); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (*send1).code); + auto receive1 (std::make_shared (send1->hash (), send1->hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (send1->hash ()))); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (*receive1).code); + + auto connection (std::make_shared (nullptr, system.nodes[0])); + std::unique_ptr req (new nano::bulk_pull{}); + req->start = receive1->hash (); + req->set_count_present (true); + req->count = 2; + connection->requests.push (std::unique_ptr{}); + auto request (std::make_shared (connection, std::move (req))); + + ASSERT_EQ (request->max_count, 2); + ASSERT_EQ (request->sent_count, 0); + + auto block (request->get_next ()); + ASSERT_EQ (receive1->hash (), block->hash ()); + + block = request->get_next (); + ASSERT_EQ (send1->hash (), block->hash ()); + + block = request->get_next (); + ASSERT_EQ (nullptr, block); +} + +TEST (bootstrap_processor, DISABLED_process_none) +{ + nano::system system (24000, 1); + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (init1.error ()); + auto done (false); + node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); + while (!done) + { + system.io_ctx.run_one (); + } + node1->stop (); +} + +// Bootstrap can pull one basic block +TEST (bootstrap_processor, process_one) +{ + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, nano::test_genesis_key.pub, 100)); + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + nano::block_hash hash1 (system.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::block_hash hash2 (node1->latest (nano::test_genesis_key.pub)); + ASSERT_NE (hash1, hash2); + node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); + ASSERT_NE (node1->latest (nano::test_genesis_key.pub), system.nodes[0]->latest (nano::test_genesis_key.pub)); + system.deadline_set (10s); + while (node1->latest (nano::test_genesis_key.pub) != system.nodes[0]->latest (nano::test_genesis_key.pub)) + { + ASSERT_NO_ERROR (system.poll ()); + } + ASSERT_EQ (0, node1->active.roots.size ()); + node1->stop (); +} + +TEST (bootstrap_processor, process_two) +{ + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::block_hash hash1 (system.nodes[0]->latest (nano::test_genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, nano::test_genesis_key.pub, 50)); + nano::block_hash hash2 (system.nodes[0]->latest (nano::test_genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, nano::test_genesis_key.pub, 50)); + nano::block_hash hash3 (system.nodes[0]->latest (nano::test_genesis_key.pub)); + ASSERT_NE (hash1, hash2); + ASSERT_NE (hash1, hash3); + ASSERT_NE (hash2, hash3); + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (init1.error ()); + node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); + ASSERT_NE (node1->latest (nano::test_genesis_key.pub), system.nodes[0]->latest (nano::test_genesis_key.pub)); + system.deadline_set (10s); + while (node1->latest (nano::test_genesis_key.pub) != system.nodes[0]->latest (nano::test_genesis_key.pub)) + { + ASSERT_NO_ERROR (system.poll ()); + } + node1->stop (); +} + +// Bootstrap can pull universal blocks +TEST (bootstrap_processor, process_state) +{ + nano::system system (24000, 1); + nano::genesis genesis; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto node0 (system.nodes[0]); + auto block1 (std::make_shared (nano::test_genesis_key.pub, node0->latest (nano::test_genesis_key.pub), nano::test_genesis_key.pub, nano::genesis_amount - 100, nano::test_genesis_key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + auto block2 (std::make_shared (nano::test_genesis_key.pub, block1->hash (), nano::test_genesis_key.pub, nano::genesis_amount, block1->hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + node0->work_generate_blocking (*block1); + node0->work_generate_blocking (*block2); + node0->process (*block1); + node0->process (*block2); + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_EQ (node0->latest (nano::test_genesis_key.pub), block2->hash ()); + ASSERT_NE (node1->latest (nano::test_genesis_key.pub), block2->hash ()); + node1->bootstrap_initiator.bootstrap (node0->network.endpoint ()); + ASSERT_NE (node1->latest (nano::test_genesis_key.pub), node0->latest (nano::test_genesis_key.pub)); + system.deadline_set (10s); + while (node1->latest (nano::test_genesis_key.pub) != node0->latest (nano::test_genesis_key.pub)) + { + ASSERT_NO_ERROR (system.poll ()); + } + ASSERT_EQ (0, node1->active.roots.size ()); + node1->stop (); +} + +TEST (bootstrap_processor, process_new) +{ + nano::system system (24000, 2); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key2; + system.wallet (1)->insert_adhoc (key2.prv); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + system.deadline_set (10s); + while (system.nodes[0]->balance (key2.pub).is_zero ()) + { + ASSERT_NO_ERROR (system.poll ()); + } + nano::uint128_t balance1 (system.nodes[0]->balance (nano::test_genesis_key.pub)); + nano::uint128_t balance2 (system.nodes[0]->balance (key2.pub)); + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24002, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (init1.error ()); + node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); + system.deadline_set (10s); + while (node1->balance (key2.pub) != balance2) + { + ASSERT_NO_ERROR (system.poll ()); + } + ASSERT_EQ (balance1, node1->balance (nano::test_genesis_key.pub)); + node1->stop (); +} + +TEST (bootstrap_processor, pull_diamond) +{ + nano::system system (24000, 1); + nano::keypair key; + auto send1 (std::make_shared (system.nodes[0]->latest (nano::test_genesis_key.pub), key.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (system.nodes[0]->latest (nano::test_genesis_key.pub)))); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (*send1).code); + auto open (std::make_shared (send1->hash (), 1, key.pub, key.prv, key.pub, system.work.generate (key.pub))); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (*open).code); + auto send2 (std::make_shared (open->hash (), nano::test_genesis_key.pub, std::numeric_limits::max () - 100, key.prv, key.pub, system.work.generate (open->hash ()))); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (*send2).code); + auto receive (std::make_shared (send1->hash (), send2->hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (send1->hash ()))); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (*receive).code); + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24002, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (init1.error ()); + node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); + system.deadline_set (10s); + while (node1->balance (nano::test_genesis_key.pub) != 100) + { + ASSERT_NO_ERROR (system.poll ()); + } + ASSERT_EQ (100, node1->balance (nano::test_genesis_key.pub)); + node1->stop (); +} + +TEST (bootstrap_processor, push_diamond) +{ + nano::system system (24000, 1); + nano::keypair key; + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24002, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (init1.error ()); + auto wallet1 (node1->wallets.create (100)); + wallet1->insert_adhoc (nano::test_genesis_key.prv); + wallet1->insert_adhoc (key.prv); + auto send1 (std::make_shared (system.nodes[0]->latest (nano::test_genesis_key.pub), key.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (system.nodes[0]->latest (nano::test_genesis_key.pub)))); + ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); + auto open (std::make_shared (send1->hash (), 1, key.pub, key.prv, key.pub, system.work.generate (key.pub))); + ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); + auto send2 (std::make_shared (open->hash (), nano::test_genesis_key.pub, std::numeric_limits::max () - 100, key.prv, key.pub, system.work.generate (open->hash ()))); + ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); + auto receive (std::make_shared (send1->hash (), send2->hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (send1->hash ()))); + ASSERT_EQ (nano::process_result::progress, node1->process (*receive).code); + node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); + system.deadline_set (10s); + while (system.nodes[0]->balance (nano::test_genesis_key.pub) != 100) + { + ASSERT_NO_ERROR (system.poll ()); + } + ASSERT_EQ (100, system.nodes[0]->balance (nano::test_genesis_key.pub)); + node1->stop (); +} + +TEST (bootstrap_processor, push_one) +{ + nano::system system (24000, 1); + nano::node_init init1; + nano::keypair key1; + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + auto wallet (node1->wallets.create (nano::uint256_union ())); + ASSERT_NE (nullptr, wallet); + wallet->insert_adhoc (nano::test_genesis_key.prv); + nano::uint128_t balance1 (node1->balance (nano::test_genesis_key.pub)); + ASSERT_NE (nullptr, wallet->send_action (nano::test_genesis_key.pub, key1.pub, 100)); + ASSERT_NE (balance1, node1->balance (nano::test_genesis_key.pub)); + node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); + system.deadline_set (10s); + while (system.nodes[0]->balance (nano::test_genesis_key.pub) == balance1) + { + ASSERT_NO_ERROR (system.poll ()); + } + node1->stop (); +} + +TEST (bootstrap_processor, lazy_hash) +{ + nano::system system (24000, 1); + nano::node_init init1; + nano::genesis genesis; + nano::keypair key1; + nano::keypair key2; + // Generating test chain + auto send1 (std::make_shared (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.nodes[0]->work_generate_blocking (genesis.hash ()))); + auto receive1 (std::make_shared (key1.pub, 0, key1.pub, nano::Gxrb_ratio, send1->hash (), key1.prv, key1.pub, system.nodes[0]->work_generate_blocking (key1.pub))); + auto send2 (std::make_shared (key1.pub, receive1->hash (), key1.pub, 0, key2.pub, key1.prv, key1.pub, system.nodes[0]->work_generate_blocking (receive1->hash ()))); + auto receive2 (std::make_shared (key2.pub, 0, key2.pub, nano::Gxrb_ratio, send2->hash (), key2.prv, key2.pub, system.nodes[0]->work_generate_blocking (key2.pub))); + // Processing test chain + system.nodes[0]->block_processor.add (send1, std::chrono::steady_clock::time_point ()); + system.nodes[0]->block_processor.add (receive1, std::chrono::steady_clock::time_point ()); + system.nodes[0]->block_processor.add (send2, std::chrono::steady_clock::time_point ()); + system.nodes[0]->block_processor.add (receive2, std::chrono::steady_clock::time_point ()); + system.nodes[0]->block_processor.flush (); + // Start lazy bootstrap with last block in chain known + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + node1->peers.insert (system.nodes[0]->network.endpoint (), nano::protocol_version); + node1->bootstrap_initiator.bootstrap_lazy (receive2->hash ()); + // Check processed blocks + system.deadline_set (10s); + while (node1->balance (key2.pub) == 0) + { + ASSERT_NO_ERROR (system.poll ()); + } + node1->stop (); +} + +TEST (bootstrap_processor, lazy_max_pull_count) +{ + nano::system system (24000, 1); + nano::node_init init1; + nano::genesis genesis; + nano::keypair key1; + nano::keypair key2; + // Generating test chain + auto send1 (std::make_shared (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.nodes[0]->work_generate_blocking (genesis.hash ()))); + auto receive1 (std::make_shared (key1.pub, 0, key1.pub, nano::Gxrb_ratio, send1->hash (), key1.prv, key1.pub, system.nodes[0]->work_generate_blocking (key1.pub))); + auto send2 (std::make_shared (key1.pub, receive1->hash (), key1.pub, 0, key2.pub, key1.prv, key1.pub, system.nodes[0]->work_generate_blocking (receive1->hash ()))); + auto receive2 (std::make_shared (key2.pub, 0, key2.pub, nano::Gxrb_ratio, send2->hash (), key2.prv, key2.pub, system.nodes[0]->work_generate_blocking (key2.pub))); + auto change1 (std::make_shared (key2.pub, receive2->hash (), key1.pub, nano::Gxrb_ratio, 0, key2.prv, key2.pub, system.nodes[0]->work_generate_blocking (receive2->hash ()))); + auto change2 (std::make_shared (key2.pub, change1->hash (), nano::test_genesis_key.pub, nano::Gxrb_ratio, 0, key2.prv, key2.pub, system.nodes[0]->work_generate_blocking (change1->hash ()))); + auto change3 (std::make_shared (key2.pub, change2->hash (), key2.pub, nano::Gxrb_ratio, 0, key2.prv, key2.pub, system.nodes[0]->work_generate_blocking (change2->hash ()))); + // Processing test chain + system.nodes[0]->block_processor.add (send1, std::chrono::steady_clock::time_point ()); + system.nodes[0]->block_processor.add (receive1, std::chrono::steady_clock::time_point ()); + system.nodes[0]->block_processor.add (send2, std::chrono::steady_clock::time_point ()); + system.nodes[0]->block_processor.add (receive2, std::chrono::steady_clock::time_point ()); + system.nodes[0]->block_processor.add (change1, std::chrono::steady_clock::time_point ()); + system.nodes[0]->block_processor.add (change2, std::chrono::steady_clock::time_point ()); + system.nodes[0]->block_processor.add (change3, std::chrono::steady_clock::time_point ()); + system.nodes[0]->block_processor.flush (); + // Start lazy bootstrap with last block in chain known + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + node1->peers.insert (system.nodes[0]->network.endpoint (), nano::protocol_version); + node1->bootstrap_initiator.bootstrap_lazy (change3->hash ()); + // Check processed blocks + system.deadline_set (10s); + while (node1->block (change3->hash ()) == nullptr) + { + ASSERT_NO_ERROR (system.poll ()); + } + node1->stop (); +} + +TEST (frontier_req_response, DISABLED_destruction) +{ + { + std::shared_ptr hold; // Destructing tcp acceptor on non-existent io_context + { + nano::system system (24000, 1); + auto connection (std::make_shared (nullptr, system.nodes[0])); + std::unique_ptr req (new nano::frontier_req); + req->start.clear (); + req->age = std::numeric_limitsage)>::max (); + req->count = std::numeric_limitscount)>::max (); + connection->requests.push (std::unique_ptr{}); + hold = std::make_shared (connection, std::move (req)); + } + } + ASSERT_TRUE (true); +} + +TEST (frontier_req, begin) +{ + nano::system system (24000, 1); + auto connection (std::make_shared (nullptr, system.nodes[0])); + std::unique_ptr req (new nano::frontier_req); + req->start.clear (); + req->age = std::numeric_limitsage)>::max (); + req->count = std::numeric_limitscount)>::max (); + connection->requests.push (std::unique_ptr{}); + auto request (std::make_shared (connection, std::move (req))); + ASSERT_EQ (nano::test_genesis_key.pub, request->current); + nano::genesis genesis; + ASSERT_EQ (genesis.hash (), request->frontier); +} + +TEST (frontier_req, end) +{ + nano::system system (24000, 1); + auto connection (std::make_shared (nullptr, system.nodes[0])); + std::unique_ptr req (new nano::frontier_req); + req->start = nano::test_genesis_key.pub.number () + 1; + req->age = std::numeric_limitsage)>::max (); + req->count = std::numeric_limitscount)>::max (); + connection->requests.push (std::unique_ptr{}); + auto request (std::make_shared (connection, std::move (req))); + ASSERT_TRUE (request->current.is_zero ()); +} + +TEST (frontier_req, count) +{ + nano::system system (24000, 1); + auto & node1 (*system.nodes[0]); + nano::genesis genesis; + // Public key FB93... after genesis in accounts table + nano::keypair key1 ("ED5AE0A6505B14B67435C29FD9FEEBC26F597D147BC92F6D795FFAD7AFD3D967"); + nano::state_block send1 (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + node1.work_generate_blocking (send1); + ASSERT_EQ (nano::process_result::progress, node1.process (send1).code); + nano::state_block receive1 (key1.pub, 0, nano::test_genesis_key.pub, nano::Gxrb_ratio, send1.hash (), key1.prv, key1.pub, 0); + node1.work_generate_blocking (receive1); + ASSERT_EQ (nano::process_result::progress, node1.process (receive1).code); + auto connection (std::make_shared (nullptr, system.nodes[0])); + std::unique_ptr req (new nano::frontier_req); + req->start.clear (); + req->age = std::numeric_limitsage)>::max (); + req->count = 1; + connection->requests.push (std::unique_ptr{}); + auto request (std::make_shared (connection, std::move (req))); + ASSERT_EQ (nano::test_genesis_key.pub, request->current); + ASSERT_EQ (send1.hash (), request->frontier); +} + +TEST (frontier_req, time_bound) +{ + nano::system system (24000, 1); + auto connection (std::make_shared (nullptr, system.nodes[0])); + std::unique_ptr req (new nano::frontier_req); + req->start.clear (); + req->age = 0; + req->count = std::numeric_limitscount)>::max (); + connection->requests.push (std::unique_ptr{}); + auto request (std::make_shared (connection, std::move (req))); + ASSERT_EQ (nano::test_genesis_key.pub, request->current); + // Wait for next second when age of account will be > 0 seconds + std::this_thread::sleep_for (std::chrono::milliseconds (1001)); + std::unique_ptr req2 (new nano::frontier_req); + req2->start.clear (); + req2->age = 0; + req2->count = std::numeric_limitscount)>::max (); + auto connection2 (std::make_shared (nullptr, system.nodes[0])); + connection2->requests.push (std::unique_ptr{}); + auto request2 (std::make_shared (connection, std::move (req2))); + ASSERT_TRUE (request2->current.is_zero ()); +} + +TEST (frontier_req, time_cutoff) +{ + nano::system system (24000, 1); + auto connection (std::make_shared (nullptr, system.nodes[0])); + std::unique_ptr req (new nano::frontier_req); + req->start.clear (); + req->age = 3; + req->count = std::numeric_limitscount)>::max (); + connection->requests.push (std::unique_ptr{}); + auto request (std::make_shared (connection, std::move (req))); + ASSERT_EQ (nano::test_genesis_key.pub, request->current); + nano::genesis genesis; + ASSERT_EQ (genesis.hash (), request->frontier); + // Wait 4 seconds when age of account will be > 3 seconds + std::this_thread::sleep_for (std::chrono::milliseconds (4001)); + std::unique_ptr req2 (new nano::frontier_req); + req2->start.clear (); + req2->age = 3; + req2->count = std::numeric_limitscount)>::max (); + auto connection2 (std::make_shared (nullptr, system.nodes[0])); + connection2->requests.push (std::unique_ptr{}); + auto request2 (std::make_shared (connection, std::move (req2))); + ASSERT_TRUE (request2->frontier.is_zero ()); +} + +TEST (bulk, genesis) +{ + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (init1.error ()); + nano::block_hash latest1 (system.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::block_hash latest2 (node1->latest (nano::test_genesis_key.pub)); + ASSERT_EQ (latest1, latest2); + nano::keypair key2; + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, 100)); + nano::block_hash latest3 (system.nodes[0]->latest (nano::test_genesis_key.pub)); + ASSERT_NE (latest1, latest3); + node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); + system.deadline_set (10s); + while (node1->latest (nano::test_genesis_key.pub) != system.nodes[0]->latest (nano::test_genesis_key.pub)) + { + ASSERT_NO_ERROR (system.poll ()); + } + ASSERT_EQ (node1->latest (nano::test_genesis_key.pub), system.nodes[0]->latest (nano::test_genesis_key.pub)); + node1->stop (); +} + +TEST (bulk, offline_send) +{ + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); + ASSERT_FALSE (init1.error ()); + node1->start (); + system.nodes.push_back (node1); + nano::keypair key2; + auto wallet (node1->wallets.create (nano::uint256_union ())); + wallet->insert_adhoc (key2.prv); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_NE (std::numeric_limits::max (), system.nodes[0]->balance (nano::test_genesis_key.pub)); + // Wait to finish election background tasks + system.deadline_set (10s); + while (!system.nodes[0]->active.roots.empty ()) + { + ASSERT_NO_ERROR (system.poll ()); + } + // Initiate bootstrap + node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); + // Nodes should find each other + do + { + ASSERT_NO_ERROR (system.poll ()); + } while (system.nodes[0]->peers.empty () || node1->peers.empty ()); + // Send block arrival via bootstrap + while (node1->balance (nano::test_genesis_key.pub) == std::numeric_limits::max ()) + { + ASSERT_NO_ERROR (system.poll ()); + } + // Receiving send block + system.deadline_set (20s); + while (node1->balance (key2.pub) != system.nodes[0]->config.receive_minimum.number ()) + { + ASSERT_NO_ERROR (system.poll ()); + } + node1->stop (); +} + +TEST (network, ipv6) +{ + boost::asio::ip::address_v6 address (boost::asio::ip::address_v6::from_string ("::ffff:127.0.0.1")); + ASSERT_TRUE (address.is_v4_mapped ()); + nano::endpoint endpoint1 (address, 16384); + std::vector bytes1; + { + nano::vectorstream stream (bytes1); + nano::write (stream, address.to_bytes ()); + } + ASSERT_EQ (16, bytes1.size ()); + for (auto i (bytes1.begin ()), n (bytes1.begin () + 10); i != n; ++i) + { + ASSERT_EQ (0, *i); + } + ASSERT_EQ (0xff, bytes1[10]); + ASSERT_EQ (0xff, bytes1[11]); + std::array bytes2; + nano::bufferstream stream (bytes1.data (), bytes1.size ()); + nano::read (stream, bytes2); + nano::endpoint endpoint2 (boost::asio::ip::address_v6 (bytes2), 16384); + ASSERT_EQ (endpoint1, endpoint2); +} + +TEST (network, ipv6_from_ipv4) +{ + nano::endpoint endpoint1 (boost::asio::ip::address_v4::loopback (), 16000); + ASSERT_TRUE (endpoint1.address ().is_v4 ()); + nano::endpoint endpoint2 (boost::asio::ip::address_v6::v4_mapped (endpoint1.address ().to_v4 ()), 16000); + ASSERT_TRUE (endpoint2.address ().is_v6 ()); +} + +TEST (network, ipv6_bind_send_ipv4) +{ + boost::asio::io_context io_ctx; + nano::endpoint endpoint1 (boost::asio::ip::address_v6::any (), 24000); + nano::endpoint endpoint2 (boost::asio::ip::address_v4::any (), 24001); + std::array bytes1; + auto finish1 (false); + nano::endpoint endpoint3; + boost::asio::ip::udp::socket socket1 (io_ctx, endpoint1); + socket1.async_receive_from (boost::asio::buffer (bytes1.data (), bytes1.size ()), endpoint3, [&finish1](boost::system::error_code const & error, size_t size_a) { + ASSERT_FALSE (error); + ASSERT_EQ (16, size_a); + finish1 = true; + }); + boost::asio::ip::udp::socket socket2 (io_ctx, endpoint2); + nano::endpoint endpoint5 (boost::asio::ip::address_v4::loopback (), 24000); + nano::endpoint endpoint6 (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4::loopback ()), 24001); + socket2.async_send_to (boost::asio::buffer (std::array{}, 16), endpoint5, [](boost::system::error_code const & error, size_t size_a) { + ASSERT_FALSE (error); + ASSERT_EQ (16, size_a); + }); + auto iterations (0); + while (!finish1) + { + io_ctx.poll (); + ++iterations; + ASSERT_LT (iterations, 200); + } + ASSERT_EQ (endpoint6, endpoint3); + std::array bytes2; + nano::endpoint endpoint4; + socket2.async_receive_from (boost::asio::buffer (bytes2.data (), bytes2.size ()), endpoint4, [](boost::system::error_code const & error, size_t size_a) { + ASSERT_FALSE (!error); + ASSERT_EQ (16, size_a); + }); + socket1.async_send_to (boost::asio::buffer (std::array{}, 16), endpoint6, [](boost::system::error_code const & error, size_t size_a) { + ASSERT_FALSE (error); + ASSERT_EQ (16, size_a); + }); +} + +TEST (network, endpoint_bad_fd) +{ + nano::system system (24000, 1); + system.nodes[0]->stop (); + auto endpoint (system.nodes[0]->network.endpoint ()); + ASSERT_TRUE (endpoint.address ().is_loopback ()); + ASSERT_EQ (0, endpoint.port ()); +} + +TEST (network, reserved_address) +{ + ASSERT_FALSE (nano::reserved_address (nano::endpoint (boost::asio::ip::address_v6::from_string ("2001::"), 0), true)); + nano::endpoint loopback (boost::asio::ip::address_v6::from_string ("::1"), 1); + ASSERT_FALSE (nano::reserved_address (loopback, false)); + ASSERT_TRUE (nano::reserved_address (loopback, true)); +} + +TEST (node, port_mapping) +{ + nano::system system (24000, 1); + auto node0 (system.nodes[0]); + node0->port_mapping.refresh_devices (); + node0->port_mapping.start (); + auto end (std::chrono::steady_clock::now () + std::chrono::seconds (500)); + (void)end; + //while (std::chrono::steady_clock::now () < end) + { + ASSERT_NO_ERROR (system.poll ()); + } +} + +TEST (udp_buffer, one_buffer) +{ + nano::stat stats; + nano::udp_buffer buffer (stats, 512, 1); + auto buffer1 (buffer.allocate ()); + ASSERT_NE (nullptr, buffer1); + buffer.enqueue (buffer1); + auto buffer2 (buffer.dequeue ()); + ASSERT_EQ (buffer1, buffer2); + buffer.release (buffer2); + auto buffer3 (buffer.allocate ()); + ASSERT_EQ (buffer1, buffer3); +} + +TEST (udp_buffer, two_buffers) +{ + nano::stat stats; + nano::udp_buffer buffer (stats, 512, 2); + auto buffer1 (buffer.allocate ()); + ASSERT_NE (nullptr, buffer1); + auto buffer2 (buffer.allocate ()); + ASSERT_NE (nullptr, buffer2); + ASSERT_NE (buffer1, buffer2); + buffer.enqueue (buffer2); + buffer.enqueue (buffer1); + auto buffer3 (buffer.dequeue ()); + ASSERT_EQ (buffer2, buffer3); + auto buffer4 (buffer.dequeue ()); + ASSERT_EQ (buffer1, buffer4); + buffer.release (buffer3); + buffer.release (buffer4); + auto buffer5 (buffer.allocate ()); + ASSERT_EQ (buffer2, buffer5); + auto buffer6 (buffer.allocate ()); + ASSERT_EQ (buffer1, buffer6); +} + +TEST (udp_buffer, one_overflow) +{ + nano::stat stats; + nano::udp_buffer buffer (stats, 512, 1); + auto buffer1 (buffer.allocate ()); + ASSERT_NE (nullptr, buffer1); + buffer.enqueue (buffer1); + auto buffer2 (buffer.allocate ()); + ASSERT_EQ (buffer1, buffer2); +} + +TEST (udp_buffer, two_overflow) +{ + nano::stat stats; + nano::udp_buffer buffer (stats, 512, 2); + auto buffer1 (buffer.allocate ()); + ASSERT_NE (nullptr, buffer1); + buffer.enqueue (buffer1); + auto buffer2 (buffer.allocate ()); + ASSERT_NE (nullptr, buffer2); + ASSERT_NE (buffer1, buffer2); + buffer.enqueue (buffer2); + auto buffer3 (buffer.allocate ()); + ASSERT_EQ (buffer1, buffer3); + auto buffer4 (buffer.allocate ()); + ASSERT_EQ (buffer2, buffer4); +} + +TEST (udp_buffer, one_buffer_multithreaded) +{ + nano::stat stats; + nano::udp_buffer buffer (stats, 512, 1); + boost::thread thread ([&buffer]() { + auto done (false); + while (!done) + { + auto item (buffer.dequeue ()); + done = item == nullptr; + if (item != nullptr) + { + buffer.release (item); + } + } + }); + auto buffer1 (buffer.allocate ()); + ASSERT_NE (nullptr, buffer1); + buffer.enqueue (buffer1); + auto buffer2 (buffer.allocate ()); + ASSERT_EQ (buffer1, buffer2); + buffer.stop (); + thread.join (); +} + +TEST (udp_buffer, many_buffers_multithreaded) +{ + nano::stat stats; + nano::udp_buffer buffer (stats, 512, 16); + std::vector threads; + for (auto i (0); i < 4; ++i) + { + threads.push_back (boost::thread ([&buffer]() { + auto done (false); + while (!done) + { + auto item (buffer.dequeue ()); + done = item == nullptr; + if (item != nullptr) + { + buffer.release (item); + } + } + })); + } + std::atomic_int count (0); + for (auto i (0); i < 4; ++i) + { + threads.push_back (boost::thread ([&buffer, &count]() { + auto done (false); + for (auto i (0); !done && i < 1000; ++i) + { + auto item (buffer.allocate ()); + done = item == nullptr; + if (item != nullptr) + { + buffer.enqueue (item); + ++count; + if (count > 3000) + { + buffer.stop (); + } + } + } + })); + } + buffer.stop (); + for (auto & i : threads) + { + i.join (); + } +} + +TEST (udp_buffer, stats) +{ + nano::stat stats; + nano::udp_buffer buffer (stats, 512, 1); + auto buffer1 (buffer.allocate ()); + buffer.enqueue (buffer1); + buffer.allocate (); + ASSERT_EQ (1, stats.count (nano::stat::type::udp, nano::stat::detail::overflow)); +} + +TEST (bulk_pull_account, basics) +{ + nano::system system (24000, 1); + system.nodes[0]->config.receive_minimum = nano::uint128_union (20); + nano::keypair key1; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (key1.prv); + auto send1 (system.wallet (0)->send_action (nano::genesis_account, key1.pub, 25)); + auto send2 (system.wallet (0)->send_action (nano::genesis_account, key1.pub, 10)); + auto send3 (system.wallet (0)->send_action (nano::genesis_account, key1.pub, 2)); + system.deadline_set (5s); + while (system.nodes[0]->balance (key1.pub) != 25) + { + ASSERT_NO_ERROR (system.poll ()); + } + auto connection (std::make_shared (nullptr, system.nodes[0])); + std::unique_ptr req (new nano::bulk_pull_account{}); + req->account = key1.pub; + req->minimum_amount = 5; + req->flags = nano::bulk_pull_account_flags (); + connection->requests.push (std::unique_ptr{}); + auto request (std::make_shared (connection, std::move (req))); + ASSERT_FALSE (request->invalid_request); + ASSERT_FALSE (request->pending_include_address); + ASSERT_FALSE (request->pending_address_only); + ASSERT_EQ (request->current_key.account, key1.pub); + ASSERT_EQ (request->current_key.hash, 0); + auto block_data (request->get_next ()); + ASSERT_EQ (send2->hash (), block_data.first.get ()->hash); + ASSERT_EQ (nano::uint128_union (10), block_data.second.get ()->amount); + ASSERT_EQ (nano::genesis_account, block_data.second.get ()->source); + ASSERT_EQ (nullptr, request->get_next ().first.get ()); +} diff --git a/rai/core_test/node.cpp b/nano/core_test/node.cpp similarity index 55% rename from rai/core_test/node.cpp rename to nano/core_test/node.cpp index 050d40fe..8b23620a 100644 --- a/rai/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -1,7 +1,7 @@ #include -#include -#include -#include +#include +#include +#include #include #include @@ -10,7 +10,7 @@ using namespace std::chrono_literals; TEST (node, stop) { - rai::system system (24000, 1); + nano::system system (24000, 1); ASSERT_NE (system.nodes[0]->wallets.items.end (), system.nodes[0]->wallets.items.begin ()); system.nodes[0]->stop (); system.io_ctx.run (); @@ -19,30 +19,30 @@ TEST (node, stop) TEST (node, block_store_path_failure) { - rai::node_init init; + nano::node_init init; auto service (boost::make_shared ()); - rai::alarm alarm (*service); - auto path (rai::unique_path ()); - rai::logging logging; + nano::alarm alarm (*service); + auto path (nano::unique_path ()); + nano::logging logging; logging.init (path); - rai::work_pool work (std::numeric_limits::max (), nullptr); - auto node (std::make_shared (init, *service, 0, path, alarm, logging, work)); + nano::work_pool work (std::numeric_limits::max (), nullptr); + auto node (std::make_shared (init, *service, 0, path, alarm, logging, work)); ASSERT_TRUE (node->wallets.items.empty ()); node->stop (); } TEST (node, password_fanout) { - rai::node_init init; + nano::node_init init; auto service (boost::make_shared ()); - rai::alarm alarm (*service); - auto path (rai::unique_path ()); - rai::node_config config; + nano::alarm alarm (*service); + auto path (nano::unique_path ()); + nano::node_config config; config.peering_port = 24000; config.logging.init (path); - rai::work_pool work (std::numeric_limits::max (), nullptr); + nano::work_pool work (std::numeric_limits::max (), nullptr); config.password_fanout = 10; - auto node (std::make_shared (init, *service, path, alarm, config, work)); + auto node (std::make_shared (init, *service, path, alarm, config, work)); auto wallet (node->wallets.create (100)); ASSERT_EQ (10, wallet->store.password.values.size ()); node->stop (); @@ -50,56 +50,56 @@ TEST (node, password_fanout) TEST (node, balance) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); auto transaction (system.nodes[0]->store.tx_begin (true)); - ASSERT_EQ (std::numeric_limits::max (), system.nodes[0]->ledger.account_balance (transaction, rai::test_genesis_key.pub)); + ASSERT_EQ (std::numeric_limits::max (), system.nodes[0]->ledger.account_balance (transaction, nano::test_genesis_key.pub)); } TEST (node, representative) { - rai::system system (24000, 1); - auto block1 (system.nodes[0]->representative (rai::test_genesis_key.pub)); + nano::system system (24000, 1); + auto block1 (system.nodes[0]->representative (nano::test_genesis_key.pub)); { auto transaction (system.nodes[0]->store.tx_begin ()); ASSERT_TRUE (system.nodes[0]->ledger.store.block_exists (transaction, block1)); } - rai::keypair key; + nano::keypair key; ASSERT_TRUE (system.nodes[0]->representative (key.pub).is_zero ()); } TEST (node, send_unkeyed) { - rai::system system (24000, 1); - rai::keypair key2; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - system.wallet (0)->store.password.value_set (rai::keypair ().prv); - ASSERT_EQ (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + nano::system system (24000, 1); + nano::keypair key2; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + system.wallet (0)->store.password.value_set (nano::keypair ().prv); + ASSERT_EQ (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); } TEST (node, send_self) { - rai::system system (24000, 1); - rai::keypair key2; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + nano::keypair key2; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key2.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); system.deadline_set (10s); while (system.nodes[0]->balance (key2.pub).is_zero ()) { ASSERT_NO_ERROR (system.poll ()); } - ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (rai::test_genesis_key.pub)); + ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (nano::test_genesis_key.pub)); } TEST (node, send_single) { - rai::system system (24000, 2); - rai::keypair key2; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 2); + nano::keypair key2; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (1)->insert_adhoc (key2.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); - ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (rai::test_genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (nano::test_genesis_key.pub)); ASSERT_TRUE (system.nodes[0]->balance (key2.pub).is_zero ()); system.deadline_set (10s); while (system.nodes[0]->balance (key2.pub).is_zero ()) @@ -110,15 +110,15 @@ TEST (node, send_single) TEST (node, send_single_observing_peer) { - rai::system system (24000, 3); - rai::keypair key2; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 3); + nano::keypair key2; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (1)->insert_adhoc (key2.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); - ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (rai::test_genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (nano::test_genesis_key.pub)); ASSERT_TRUE (system.nodes[0]->balance (key2.pub).is_zero ()); system.deadline_set (10s); - while (std::any_of (system.nodes.begin (), system.nodes.end (), [&](std::shared_ptr const & node_a) { return node_a->balance (key2.pub).is_zero (); })) + while (std::any_of (system.nodes.begin (), system.nodes.end (), [&](std::shared_ptr const & node_a) { return node_a->balance (key2.pub).is_zero (); })) { ASSERT_NO_ERROR (system.poll ()); } @@ -126,15 +126,15 @@ TEST (node, send_single_observing_peer) TEST (node, send_single_many_peers) { - rai::system system (24000, 10); - rai::keypair key2; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 10); + nano::keypair key2; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (1)->insert_adhoc (key2.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); - ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (rai::test_genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (nano::test_genesis_key.pub)); ASSERT_TRUE (system.nodes[0]->balance (key2.pub).is_zero ()); system.deadline_set (3.5min); - while (std::any_of (system.nodes.begin (), system.nodes.end (), [&](std::shared_ptr const & node_a) { return node_a->balance (key2.pub).is_zero (); })) + while (std::any_of (system.nodes.begin (), system.nodes.end (), [&](std::shared_ptr const & node_a) { return node_a->balance (key2.pub).is_zero (); })) { ASSERT_NO_ERROR (system.poll ()); } @@ -142,17 +142,17 @@ TEST (node, send_single_many_peers) TEST (node, send_out_of_order) { - rai::system system (24000, 2); - rai::keypair key2; - rai::genesis genesis; - rai::send_block send1 (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ())); - rai::send_block send2 (send1.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number () * 2, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (send1.hash ())); - rai::send_block send3 (send2.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number () * 3, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (send2.hash ())); - system.nodes[0]->process_active (std::make_shared (send3)); - system.nodes[0]->process_active (std::make_shared (send2)); - system.nodes[0]->process_active (std::make_shared (send1)); + nano::system system (24000, 2); + nano::keypair key2; + nano::genesis genesis; + nano::send_block send1 (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ())); + nano::send_block send2 (send1.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number () * 2, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (send1.hash ())); + nano::send_block send3 (send2.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number () * 3, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (send2.hash ())); + system.nodes[0]->process_active (std::make_shared (send3)); + system.nodes[0]->process_active (std::make_shared (send2)); + system.nodes[0]->process_active (std::make_shared (send1)); system.deadline_set (10s); - while (std::any_of (system.nodes.begin (), system.nodes.end (), [&](std::shared_ptr const & node_a) { return node_a->balance (rai::test_genesis_key.pub) != rai::genesis_amount - system.nodes[0]->config.receive_minimum.number () * 3; })) + while (std::any_of (system.nodes.begin (), system.nodes.end (), [&](std::shared_ptr const & node_a) { return node_a->balance (nano::test_genesis_key.pub) != nano::genesis_amount - system.nodes[0]->config.receive_minimum.number () * 3; })) { ASSERT_NO_ERROR (system.poll ()); } @@ -160,30 +160,30 @@ TEST (node, send_out_of_order) TEST (node, quick_confirm) { - rai::system system (24000, 1); - rai::keypair key; - rai::block_hash previous (system.nodes[0]->latest (rai::test_genesis_key.pub)); - auto genesis_start_balance (system.nodes[0]->balance (rai::test_genesis_key.pub)); + nano::system system (24000, 1); + nano::keypair key; + nano::block_hash previous (system.nodes[0]->latest (nano::test_genesis_key.pub)); + auto genesis_start_balance (system.nodes[0]->balance (nano::test_genesis_key.pub)); system.wallet (0)->insert_adhoc (key.prv); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto send (std::make_shared (previous, key.pub, system.nodes[0]->config.online_weight_minimum.number () + 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (previous))); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto send (std::make_shared (previous, key.pub, system.nodes[0]->config.online_weight_minimum.number () + 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (previous))); system.nodes[0]->process_active (send); system.deadline_set (10s); while (system.nodes[0]->balance (key.pub).is_zero ()) { ASSERT_NO_ERROR (system.poll ()); } - ASSERT_EQ (system.nodes[0]->balance (rai::test_genesis_key.pub), system.nodes[0]->config.online_weight_minimum.number () + 1); + ASSERT_EQ (system.nodes[0]->balance (nano::test_genesis_key.pub), system.nodes[0]->config.online_weight_minimum.number () + 1); ASSERT_EQ (system.nodes[0]->balance (key.pub), genesis_start_balance - (system.nodes[0]->config.online_weight_minimum.number () + 1)); } TEST (node, node_receive_quorum) { - rai::system system (24000, 1); - rai::keypair key; - rai::block_hash previous (system.nodes[0]->latest (rai::test_genesis_key.pub)); + nano::system system (24000, 1); + nano::keypair key; + nano::block_hash previous (system.nodes[0]->latest (nano::test_genesis_key.pub)); system.wallet (0)->insert_adhoc (key.prv); - auto send (std::make_shared (previous, key.pub, rai::genesis_amount - rai::Gxrb_ratio, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (previous))); + auto send (std::make_shared (previous, key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (previous))); system.nodes[0]->process_active (send); system.deadline_set (10s); while (!system.nodes[0]->ledger.block_exists (send->hash ())) @@ -195,11 +195,11 @@ TEST (node, node_receive_quorum) { auto info (system.nodes[0]->active.roots.find (previous)); ASSERT_NE (system.nodes[0]->active.roots.end (), info); - done = info->election->announcements > rai::active_transactions::announcement_min; + done = info->election->announcements > nano::active_transactions::announcement_min; ASSERT_NO_ERROR (system.poll ()); } - rai::system system2 (24001, 1); - system2.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system2 (24001, 1); + system2.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); ASSERT_TRUE (system.nodes[0]->balance (key.pub).is_zero ()); system.nodes[0]->network.send_keepalive (system2.nodes[0]->network.endpoint ()); while (system.nodes[0]->balance (key.pub).is_zero ()) @@ -211,18 +211,18 @@ TEST (node, node_receive_quorum) TEST (node, auto_bootstrap) { - rai::system system (24000, 1); - rai::keypair key2; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + nano::keypair key2; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key2.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); system.deadline_set (10s); while (system.nodes[0]->balance (key2.pub) != system.nodes[0]->config.receive_minimum.number ()) { ASSERT_NO_ERROR (system.poll ()); } - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); ASSERT_FALSE (init1.error ()); node1->network.send_keepalive (system.nodes[0]->network.endpoint ()); node1->start (); @@ -246,14 +246,14 @@ TEST (node, auto_bootstrap) TEST (node, auto_bootstrap_reverse) { - rai::system system (24000, 1); - rai::keypair key2; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + nano::keypair key2; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key2.prv); - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); ASSERT_FALSE (init1.error ()); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); system.nodes[0]->network.send_keepalive (node1->network.endpoint ()); node1->start (); system.nodes.push_back (node1); @@ -267,12 +267,12 @@ TEST (node, auto_bootstrap_reverse) TEST (node, receive_gap) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto & node1 (*system.nodes[0]); ASSERT_EQ (0, node1.gap_cache.blocks.size ()); - auto block (std::make_shared (5, 1, 2, rai::keypair ().prv, 4, 0)); + auto block (std::make_shared (5, 1, 2, nano::keypair ().prv, 4, 0)); node1.work_generate_blocking (*block); - rai::publish message (block); + nano::publish message (block); node1.process_message (message, node1.network.endpoint ()); node1.block_processor.flush (); ASSERT_EQ (1, node1.gap_cache.blocks.size ()); @@ -280,20 +280,20 @@ TEST (node, receive_gap) TEST (node, merge_peers) { - rai::system system (24000, 1); - std::array endpoints; - endpoints.fill (rai::endpoint (boost::asio::ip::address_v6::loopback (), 24000)); - endpoints[0] = rai::endpoint (boost::asio::ip::address_v6::loopback (), 24001); + nano::system system (24000, 1); + std::array endpoints; + endpoints.fill (nano::endpoint (boost::asio::ip::address_v6::loopback (), 24000)); + endpoints[0] = nano::endpoint (boost::asio::ip::address_v6::loopback (), 24001); system.nodes[0]->network.merge_peers (endpoints); ASSERT_EQ (0, system.nodes[0]->peers.peers.size ()); } TEST (node, search_pending) { - rai::system system (24000, 1); - rai::keypair key2; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + nano::system system (24000, 1); + nano::keypair key2; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); system.wallet (0)->insert_adhoc (key2.prv); auto node (system.nodes[0]); ASSERT_FALSE (system.wallet (0)->search_pending ()); @@ -306,11 +306,11 @@ TEST (node, search_pending) TEST (node, search_pending_same) { - rai::system system (24000, 1); - rai::keypair key2; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + nano::system system (24000, 1); + nano::keypair key2; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); system.wallet (0)->insert_adhoc (key2.prv); auto node (system.nodes[0]); ASSERT_FALSE (system.wallet (0)->search_pending ()); @@ -323,18 +323,18 @@ TEST (node, search_pending_same) TEST (node, search_pending_multiple) { - rai::system system (24000, 1); - rai::keypair key2; - rai::keypair key3; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + nano::keypair key2; + nano::keypair key3; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key3.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key3.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key3.pub, system.nodes[0]->config.receive_minimum.number ())); system.deadline_set (10s); while (system.nodes[0]->balance (key3.pub).is_zero ()) { ASSERT_NO_ERROR (system.poll ()); } - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); ASSERT_NE (nullptr, system.wallet (0)->send_action (key3.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); system.wallet (0)->insert_adhoc (key2.prv); auto node (system.nodes[0]); @@ -348,22 +348,22 @@ TEST (node, search_pending_multiple) TEST (node, unlock_search) { - rai::system system (24000, 1); - rai::keypair key2; - rai::uint128_t balance (system.nodes[0]->balance (rai::test_genesis_key.pub)); + nano::system system (24000, 1); + nano::keypair key2; + nano::uint128_t balance (system.nodes[0]->balance (nano::test_genesis_key.pub)); { auto transaction (system.wallet (0)->wallets.tx_begin (true)); system.wallet (0)->store.rekey (transaction, ""); } - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); system.deadline_set (10s); - while (system.nodes[0]->balance (rai::test_genesis_key.pub) == balance) + while (system.nodes[0]->balance (nano::test_genesis_key.pub) == balance) { ASSERT_NO_ERROR (system.poll ()); } system.wallet (0)->insert_adhoc (key2.prv); - system.wallet (0)->store.password.value_set (rai::keypair ().prv); + system.wallet (0)->store.password.value_set (nano::keypair ().prv); auto node (system.nodes[0]); { auto transaction (system.wallet (0)->wallets.tx_begin (true)); @@ -378,13 +378,13 @@ TEST (node, unlock_search) TEST (node, connect_after_junk) { - rai::system system (24000, 1); - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); + nano::system system (24000, 1); + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); uint64_t junk (0); node1->network.socket.async_send_to (boost::asio::buffer (&junk, sizeof (junk)), system.nodes[0]->network.endpoint (), [](boost::system::error_code const &, size_t) {}); system.deadline_set (10s); - while (system.nodes[0]->stats.count (rai::stat::type::error) == 0) + while (system.nodes[0]->stats.count (nano::stat::type::error) == 0) { ASSERT_NO_ERROR (system.poll ()); } @@ -401,14 +401,14 @@ TEST (node, connect_after_junk) TEST (node, working) { - auto path (rai::working_path ()); + auto path (nano::working_path ()); ASSERT_FALSE (path.empty ()); } TEST (logging, serialization) { - auto path (rai::unique_path ()); - rai::logging logging1; + auto path (nano::unique_path ()); + nano::logging logging1; logging1.init (path); logging1.ledger_logging_value = !logging1.ledger_logging_value; logging1.ledger_duplicate_logging_value = !logging1.ledger_duplicate_logging_value; @@ -427,7 +427,7 @@ TEST (logging, serialization) logging1.max_size = 10; boost::property_tree::ptree tree; logging1.serialize_json (tree); - rai::logging logging2; + nano::logging logging2; logging2.init (path); bool upgraded (false); ASSERT_FALSE (logging2.deserialize_json (upgraded, tree)); @@ -451,11 +451,11 @@ TEST (logging, serialization) TEST (logging, upgrade_v1_v2) { - auto path1 (rai::unique_path ()); - auto path2 (rai::unique_path ()); - rai::logging logging1; + auto path1 (nano::unique_path ()); + auto path2 (nano::unique_path ()); + nano::logging logging1; logging1.init (path1); - rai::logging logging2; + nano::logging logging2; logging2.init (path2); boost::property_tree::ptree tree; logging1.serialize_json (tree); @@ -469,23 +469,23 @@ TEST (logging, upgrade_v1_v2) TEST (node, price) { - rai::system system (24000, 1); - auto price1 (system.nodes[0]->price (rai::Gxrb_ratio, 1)); - ASSERT_EQ (rai::node::price_max * 100.0, price1); - auto price2 (system.nodes[0]->price (rai::Gxrb_ratio * int(rai::node::free_cutoff + 1), 1)); + nano::system system (24000, 1); + auto price1 (system.nodes[0]->price (nano::Gxrb_ratio, 1)); + ASSERT_EQ (nano::node::price_max * 100.0, price1); + auto price2 (system.nodes[0]->price (nano::Gxrb_ratio * int(nano::node::free_cutoff + 1), 1)); ASSERT_EQ (0, price2); - auto price3 (system.nodes[0]->price (rai::Gxrb_ratio * int(rai::node::free_cutoff + 2) / 2, 1)); - ASSERT_EQ (rai::node::price_max * 100.0 / 2, price3); - auto price4 (system.nodes[0]->price (rai::Gxrb_ratio * int(rai::node::free_cutoff) * 2, 1)); + auto price3 (system.nodes[0]->price (nano::Gxrb_ratio * int(nano::node::free_cutoff + 2) / 2, 1)); + ASSERT_EQ (nano::node::price_max * 100.0 / 2, price3); + auto price4 (system.nodes[0]->price (nano::Gxrb_ratio * int(nano::node::free_cutoff) * 2, 1)); ASSERT_EQ (0, price4); } TEST (node_config, serialization) { - auto path (rai::unique_path ()); - rai::logging logging1; + auto path (nano::unique_path ()); + nano::logging logging1; logging1.init (path); - rai::node_config config1 (100, logging1); + nano::node_config config1 (100, logging1); config1.bootstrap_fraction_numerator = 10; config1.receive_minimum = 10; config1.online_weight_minimum = 10; @@ -498,10 +498,10 @@ TEST (node_config, serialization) config1.lmdb_max_dbs = 256; boost::property_tree::ptree tree; config1.serialize_json (tree); - rai::logging logging2; + nano::logging logging2; logging2.init (path); logging2.node_lifetime_tracing_value = !logging2.node_lifetime_tracing_value; - rai::node_config config2 (50, logging2); + nano::node_config config2 (50, logging2); ASSERT_NE (config2.bootstrap_fraction_numerator, config1.bootstrap_fraction_numerator); ASSERT_NE (config2.peering_port, config1.peering_port); ASSERT_NE (config2.logging.node_lifetime_tracing_value, config1.logging.node_lifetime_tracing_value); @@ -535,8 +535,8 @@ TEST (node_config, serialization) TEST (node_config, v1_v2_upgrade) { - auto path (rai::unique_path ()); - rai::logging logging1; + auto path (nano::unique_path ()); + nano::logging logging1; logging1.init (path); boost::property_tree::ptree tree; tree.put ("peering_port", std::to_string (0)); @@ -544,7 +544,7 @@ TEST (node_config, v1_v2_upgrade) tree.put ("bootstrap_fraction_numerator", std::to_string (0)); tree.put ("creation_rebroadcast", std::to_string (0)); tree.put ("rebroadcast_delay", std::to_string (0)); - tree.put ("receive_minimum", rai::amount (0).to_string_dec ()); + tree.put ("receive_minimum", nano::amount (0).to_string_dec ()); boost::property_tree::ptree logging_l; logging1.serialize_json (logging_l); tree.add_child ("logging", logging_l); @@ -553,7 +553,7 @@ TEST (node_config, v1_v2_upgrade) boost::property_tree::ptree preconfigured_representatives_l; tree.add_child ("preconfigured_representatives", preconfigured_representatives_l); bool upgraded (false); - rai::node_config config1; + nano::node_config config1; config1.logging.init (path); ASSERT_FALSE (tree.get_child_optional ("work_peers")); config1.deserialize_json (upgraded, tree); @@ -563,8 +563,8 @@ TEST (node_config, v1_v2_upgrade) TEST (node_config, v2_v3_upgrade) { - auto path (rai::unique_path ()); - rai::logging logging1; + auto path (nano::unique_path ()); + nano::logging logging1; logging1.init (path); boost::property_tree::ptree tree; tree.put ("peering_port", std::to_string (0)); @@ -572,7 +572,7 @@ TEST (node_config, v2_v3_upgrade) tree.put ("bootstrap_fraction_numerator", std::to_string (0)); tree.put ("creation_rebroadcast", std::to_string (0)); tree.put ("rebroadcast_delay", std::to_string (0)); - tree.put ("receive_minimum", rai::amount (0).to_string_dec ()); + tree.put ("receive_minimum", nano::amount (0).to_string_dec ()); tree.put ("version", "2"); boost::property_tree::ptree logging_l; logging1.serialize_json (logging_l); @@ -587,14 +587,14 @@ TEST (node_config, v2_v3_upgrade) boost::property_tree::ptree work_peers_l; tree.add_child ("work_peers", work_peers_l); bool upgraded (false); - rai::node_config config1; + nano::node_config config1; config1.logging.init (path); ASSERT_FALSE (tree.get_optional ("inactive_supply")); ASSERT_FALSE (tree.get_optional ("password_fanout")); ASSERT_FALSE (tree.get_optional ("io_threads")); ASSERT_FALSE (tree.get_optional ("work_threads")); config1.deserialize_json (upgraded, tree); - //ASSERT_EQ (rai::uint128_union (0).to_string_dec (), tree.get ("inactive_supply")); + //ASSERT_EQ (nano::uint128_union (0).to_string_dec (), tree.get ("inactive_supply")); ASSERT_EQ ("1024", tree.get ("password_fanout")); ASSERT_NE (0, std::stoul (tree.get ("password_fanout"))); ASSERT_NE (0, std::stoul (tree.get ("password_fanout"))); @@ -605,38 +605,38 @@ TEST (node_config, v2_v3_upgrade) TEST (node, confirm_locked) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); auto transaction (system.nodes[0]->store.tx_begin ()); system.wallet (0)->enter_password (transaction, "1"); - auto block (std::make_shared (0, 0, 0, rai::keypair ().prv, 0, 0)); + auto block (std::make_shared (0, 0, 0, nano::keypair ().prv, 0, 0)); system.nodes[0]->network.republish_block (block); } TEST (node_config, random_rep) { - auto path (rai::unique_path ()); - rai::logging logging1; + auto path (nano::unique_path ()); + nano::logging logging1; logging1.init (path); - rai::node_config config1 (100, logging1); + nano::node_config config1 (100, logging1); auto rep (config1.random_representative ()); ASSERT_NE (config1.preconfigured_representatives.end (), std::find (config1.preconfigured_representatives.begin (), config1.preconfigured_representatives.end (), rep)); } TEST (node, fork_publish) { - std::weak_ptr node0; + std::weak_ptr node0; { - rai::system system (24000, 1); + nano::system system (24000, 1); node0 = system.nodes[0]; auto & node1 (*system.nodes[0]); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key1; - rai::genesis genesis; - auto send1 (std::make_shared (genesis.hash (), key1.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key1; + nano::genesis genesis; + auto send1 (std::make_shared (genesis.hash (), key1.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node1.work_generate_blocking (*send1); - rai::keypair key2; - auto send2 (std::make_shared (genesis.hash (), key2.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + nano::keypair key2; + auto send2 (std::make_shared (genesis.hash (), key2.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node1.work_generate_blocking (*send2); node1.process_active (send1); node1.block_processor.flush (); @@ -650,35 +650,35 @@ TEST (node, fork_publish) ASSERT_EQ (2, election->last_votes.size ()); node1.process_active (send2); node1.block_processor.flush (); - auto existing1 (election->last_votes.find (rai::test_genesis_key.pub)); + auto existing1 (election->last_votes.find (nano::test_genesis_key.pub)); ASSERT_NE (election->last_votes.end (), existing1); ASSERT_EQ (send1->hash (), existing1->second.hash); auto winner (*election->tally (transaction).begin ()); ASSERT_EQ (*send1, *winner.second); - ASSERT_EQ (rai::genesis_amount - 100, winner.first); + ASSERT_EQ (nano::genesis_amount - 100, winner.first); } ASSERT_TRUE (node0.expired ()); } TEST (node, fork_keep) { - rai::system system (24000, 2); + nano::system system (24000, 2); auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); ASSERT_EQ (1, node1.peers.size ()); - rai::keypair key1; - rai::keypair key2; - rai::genesis genesis; + nano::keypair key1; + nano::keypair key2; + nano::genesis genesis; // send1 and send2 fork to different accounts - auto send1 (std::make_shared (genesis.hash (), key1.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); - auto send2 (std::make_shared (genesis.hash (), key2.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + auto send1 (std::make_shared (genesis.hash (), key1.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + auto send2 (std::make_shared (genesis.hash (), key2.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); node1.process_active (send1); node1.block_processor.flush (); node2.process_active (send1); node2.block_processor.flush (); ASSERT_EQ (1, node1.active.roots.size ()); ASSERT_EQ (1, node2.active.roots.size ()); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); node1.process_active (send2); node1.block_processor.flush (); node2.process_active (send2); @@ -705,31 +705,31 @@ TEST (node, fork_keep) // The vote should be in agreement with what we already have. auto winner (*votes1->tally (transaction1).begin ()); ASSERT_EQ (*send1, *winner.second); - ASSERT_EQ (rai::genesis_amount - 100, winner.first); + ASSERT_EQ (nano::genesis_amount - 100, winner.first); ASSERT_TRUE (system.nodes[0]->store.block_exists (transaction0, send1->hash ())); ASSERT_TRUE (system.nodes[1]->store.block_exists (transaction1, send1->hash ())); } TEST (node, fork_flip) { - rai::system system (24000, 2); + nano::system system (24000, 2); auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); ASSERT_EQ (1, node1.peers.size ()); - rai::keypair key1; - rai::genesis genesis; - auto send1 (std::make_shared (genesis.hash (), key1.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); - rai::publish publish1 (send1); - rai::keypair key2; - auto send2 (std::make_shared (genesis.hash (), key2.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); - rai::publish publish2 (send2); + nano::keypair key1; + nano::genesis genesis; + auto send1 (std::make_shared (genesis.hash (), key1.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + nano::publish publish1 (send1); + nano::keypair key2; + auto send2 (std::make_shared (genesis.hash (), key2.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + nano::publish publish2 (send2); node1.process_message (publish1, node1.network.endpoint ()); node1.block_processor.flush (); node2.process_message (publish2, node1.network.endpoint ()); node2.block_processor.flush (); ASSERT_EQ (1, node1.active.roots.size ()); ASSERT_EQ (1, node2.active.roots.size ()); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); node1.process_message (publish2, node1.network.endpoint ()); node1.block_processor.flush (); node2.process_message (publish1, node2.network.endpoint ()); @@ -758,7 +758,7 @@ TEST (node, fork_flip) auto transaction2 (system.nodes[1]->store.tx_begin ()); auto winner (*votes1->tally (transaction2).begin ()); ASSERT_EQ (*publish1.block, *winner.second); - ASSERT_EQ (rai::genesis_amount - 100, winner.first); + ASSERT_EQ (nano::genesis_amount - 100, winner.first); ASSERT_TRUE (node1.store.block_exists (transaction1, publish1.block->hash ())); ASSERT_TRUE (node2.store.block_exists (transaction2, publish1.block->hash ())); ASSERT_FALSE (node2.store.block_exists (transaction2, publish2.block->hash ())); @@ -766,19 +766,19 @@ TEST (node, fork_flip) TEST (node, fork_multi_flip) { - rai::system system (24000, 2); + nano::system system (24000, 2); auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); ASSERT_EQ (1, node1.peers.size ()); - rai::keypair key1; - rai::genesis genesis; - auto send1 (std::make_shared (genesis.hash (), key1.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); - rai::publish publish1 (send1); - rai::keypair key2; - auto send2 (std::make_shared (genesis.hash (), key2.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); - rai::publish publish2 (send2); - auto send3 (std::make_shared (publish2.block->hash (), key2.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (publish2.block->hash ()))); - rai::publish publish3 (send3); + nano::keypair key1; + nano::genesis genesis; + auto send1 (std::make_shared (genesis.hash (), key1.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + nano::publish publish1 (send1); + nano::keypair key2; + auto send2 (std::make_shared (genesis.hash (), key2.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + nano::publish publish2 (send2); + auto send3 (std::make_shared (publish2.block->hash (), key2.pub, nano::genesis_amount - 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (publish2.block->hash ()))); + nano::publish publish3 (send3); node1.process_message (publish1, node1.network.endpoint ()); node1.block_processor.flush (); node2.process_message (publish2, node2.network.endpoint ()); @@ -786,7 +786,7 @@ TEST (node, fork_multi_flip) node2.block_processor.flush (); ASSERT_EQ (1, node1.active.roots.size ()); ASSERT_EQ (2, node2.active.roots.size ()); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); node1.process_message (publish2, node1.network.endpoint ()); node1.process_message (publish3, node1.network.endpoint ()); node1.block_processor.flush (); @@ -817,7 +817,7 @@ TEST (node, fork_multi_flip) auto transaction2 (system.nodes[1]->store.tx_begin ()); auto winner (*votes1->tally (transaction2).begin ()); ASSERT_EQ (*publish1.block, *winner.second); - ASSERT_EQ (rai::genesis_amount - 100, winner.first); + ASSERT_EQ (nano::genesis_amount - 100, winner.first); ASSERT_TRUE (node1.store.block_exists (transaction1, publish1.block->hash ())); ASSERT_TRUE (node2.store.block_exists (transaction2, publish1.block->hash ())); ASSERT_FALSE (node2.store.block_exists (transaction2, publish2.block->hash ())); @@ -828,16 +828,16 @@ TEST (node, fork_multi_flip) // This could happen if a fork wasn't resolved before the process previously shut down TEST (node, fork_bootstrap_flip) { - rai::system system0 (24000, 1); - rai::system system1 (24001, 1); + nano::system system0 (24000, 1); + nano::system system1 (24001, 1); auto & node1 (*system0.nodes[0]); auto & node2 (*system1.nodes[0]); - system0.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::block_hash latest (system0.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::keypair key1; - auto send1 (std::make_shared (latest, key1.pub, rai::genesis_amount - rai::Gxrb_ratio, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system0.work.generate (latest))); - rai::keypair key2; - auto send2 (std::make_shared (latest, key2.pub, rai::genesis_amount - rai::Gxrb_ratio, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system0.work.generate (latest))); + system0.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::block_hash latest (system0.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::keypair key1; + auto send1 (std::make_shared (latest, key1.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system0.work.generate (latest))); + nano::keypair key2; + auto send2 (std::make_shared (latest, key2.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system0.work.generate (latest))); // Insert but don't rebroadcast, simulating settled blocks node1.block_processor.add (send1, std::chrono::steady_clock::now ()); node1.block_processor.flush (); @@ -868,43 +868,43 @@ TEST (node, fork_bootstrap_flip) TEST (node, fork_open) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto & node1 (*system.nodes[0]); - rai::keypair key1; - rai::genesis genesis; - auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); - rai::publish publish1 (send1); + nano::keypair key1; + nano::genesis genesis; + auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + nano::publish publish1 (send1); node1.process_message (publish1, node1.network.endpoint ()); node1.block_processor.flush (); - auto open1 (std::make_shared (publish1.block->hash (), 1, key1.pub, key1.prv, key1.pub, system.work.generate (key1.pub))); - rai::publish publish2 (open1); + auto open1 (std::make_shared (publish1.block->hash (), 1, key1.pub, key1.prv, key1.pub, system.work.generate (key1.pub))); + nano::publish publish2 (open1); node1.process_message (publish2, node1.network.endpoint ()); node1.block_processor.flush (); - auto open2 (std::make_shared (publish1.block->hash (), 2, key1.pub, key1.prv, key1.pub, system.work.generate (key1.pub))); - rai::publish publish3 (open2); + auto open2 (std::make_shared (publish1.block->hash (), 2, key1.pub, key1.prv, key1.pub, system.work.generate (key1.pub))); + nano::publish publish3 (open2); ASSERT_EQ (2, node1.active.roots.size ()); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); node1.process_message (publish3, node1.network.endpoint ()); node1.block_processor.flush (); } TEST (node, fork_open_flip) { - rai::system system (24000, 2); + nano::system system (24000, 2); auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); ASSERT_EQ (1, node1.peers.size ()); - rai::keypair key1; - rai::genesis genesis; - rai::keypair rep1; - rai::keypair rep2; - auto send1 (std::make_shared (genesis.hash (), key1.pub, rai::genesis_amount - 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + nano::keypair key1; + nano::genesis genesis; + nano::keypair rep1; + nano::keypair rep2; + auto send1 (std::make_shared (genesis.hash (), key1.pub, nano::genesis_amount - 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); node1.process_active (send1); node2.process_active (send1); // We should be keeping this block - auto open1 (std::make_shared (send1->hash (), rep1.pub, key1.pub, key1.prv, key1.pub, system.work.generate (key1.pub))); + auto open1 (std::make_shared (send1->hash (), rep1.pub, key1.pub, key1.prv, key1.pub, system.work.generate (key1.pub))); // This block should be evicted - auto open2 (std::make_shared (send1->hash (), rep2.pub, key1.pub, key1.prv, key1.pub, system.work.generate (key1.pub))); + auto open2 (std::make_shared (send1->hash (), rep2.pub, key1.pub, key1.prv, key1.pub, system.work.generate (key1.pub))); ASSERT_FALSE (*open1 == *open2); // node1 gets copy that will remain node1.process_active (open1); @@ -914,7 +914,7 @@ TEST (node, fork_open_flip) node2.block_processor.flush (); ASSERT_EQ (2, node1.active.roots.size ()); ASSERT_EQ (2, node2.active.roots.size ()); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); // Notify both nodes that a fork exists node1.process_active (open2); node1.block_processor.flush (); @@ -938,7 +938,7 @@ TEST (node, fork_open_flip) auto transaction2 (system.nodes[1]->store.tx_begin ()); auto winner (*votes1->tally (transaction2).begin ()); ASSERT_EQ (*open1, *winner.second); - ASSERT_EQ (rai::genesis_amount - 1, winner.first); + ASSERT_EQ (nano::genesis_amount - 1, winner.first); ASSERT_TRUE (node1.store.block_exists (transaction1, open1->hash ())); ASSERT_TRUE (node2.store.block_exists (transaction2, open1->hash ())); ASSERT_FALSE (node2.store.block_exists (transaction2, open2->hash ())); @@ -946,32 +946,32 @@ TEST (node, fork_open_flip) TEST (node, coherent_observer) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto & node1 (*system.nodes[0]); - node1.observers.blocks.add ([&node1](std::shared_ptr block_a, rai::account const &, rai::uint128_t const &, bool) { + node1.observers.blocks.add ([&node1](std::shared_ptr block_a, nano::account const &, nano::uint128_t const &, bool) { auto transaction (node1.store.tx_begin ()); ASSERT_TRUE (node1.store.block_exists (transaction, block_a->hash ())); }); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key; - system.wallet (0)->send_action (rai::test_genesis_key.pub, key.pub, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key; + system.wallet (0)->send_action (nano::test_genesis_key.pub, key.pub, 1); } TEST (node, fork_no_vote_quorum) { - rai::system system (24000, 3); + nano::system system (24000, 3); auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); auto & node3 (*system.nodes[2]); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); auto key4 (system.wallet (0)->deterministic_insert ()); - system.wallet (0)->send_action (rai::test_genesis_key.pub, key4, rai::genesis_amount / 4); + system.wallet (0)->send_action (nano::test_genesis_key.pub, key4, nano::genesis_amount / 4); auto key1 (system.wallet (1)->deterministic_insert ()); { auto transaction (system.wallet (1)->wallets.tx_begin (true)); system.wallet (1)->store.representative_set (transaction, key1); } - auto block (system.wallet (0)->send_action (rai::test_genesis_key.pub, key1, node1.config.receive_minimum.number ())); + auto block (system.wallet (0)->send_action (nano::test_genesis_key.pub, key1, node1.config.receive_minimum.number ())); ASSERT_NE (nullptr, block); system.deadline_set (30s); while (node3.balance (key1) != node1.config.receive_minimum.number () || node2.balance (key1) != node1.config.receive_minimum.number () || node1.balance (key1) != node1.config.receive_minimum.number ()) @@ -981,70 +981,70 @@ TEST (node, fork_no_vote_quorum) ASSERT_EQ (node1.config.receive_minimum.number (), node1.weight (key1)); ASSERT_EQ (node1.config.receive_minimum.number (), node2.weight (key1)); ASSERT_EQ (node1.config.receive_minimum.number (), node3.weight (key1)); - rai::state_block send1 (rai::test_genesis_key.pub, block->hash (), rai::test_genesis_key.pub, (rai::genesis_amount / 4) - (node1.config.receive_minimum.number () * 2), key1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (block->hash ())); - ASSERT_EQ (rai::process_result::progress, node1.process (send1).code); - ASSERT_EQ (rai::process_result::progress, node2.process (send1).code); - ASSERT_EQ (rai::process_result::progress, node3.process (send1).code); + nano::state_block send1 (nano::test_genesis_key.pub, block->hash (), nano::test_genesis_key.pub, (nano::genesis_amount / 4) - (node1.config.receive_minimum.number () * 2), key1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (block->hash ())); + ASSERT_EQ (nano::process_result::progress, node1.process (send1).code); + ASSERT_EQ (nano::process_result::progress, node2.process (send1).code); + ASSERT_EQ (nano::process_result::progress, node3.process (send1).code); auto key2 (system.wallet (2)->deterministic_insert ()); - auto send2 (std::make_shared (block->hash (), key2, (rai::genesis_amount / 4) - (node1.config.receive_minimum.number () * 2), rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (block->hash ()))); - rai::raw_key key3; + auto send2 (std::make_shared (block->hash (), key2, (nano::genesis_amount / 4) - (node1.config.receive_minimum.number () * 2), nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (block->hash ()))); + nano::raw_key key3; auto transaction (system.wallet (1)->wallets.tx_begin ()); ASSERT_FALSE (system.wallet (1)->store.fetch (transaction, key1, key3)); - auto vote (std::make_shared (key1, key3, 0, send2)); - rai::confirm_ack confirm (vote); + auto vote (std::make_shared (key1, key3, 0, send2)); + nano::confirm_ack confirm (vote); std::shared_ptr> bytes (new std::vector); { - rai::vectorstream stream (*bytes); + nano::vectorstream stream (*bytes); confirm.serialize (stream); } node2.network.confirm_send (confirm, bytes, node3.network.endpoint ()); - while (node3.stats.count (rai::stat::type::message, rai::stat::detail::confirm_ack, rai::stat::dir::in) < 3) + while (node3.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::in) < 3) { ASSERT_NO_ERROR (system.poll ()); } - ASSERT_TRUE (node1.latest (rai::test_genesis_key.pub) == send1.hash ()); - ASSERT_TRUE (node2.latest (rai::test_genesis_key.pub) == send1.hash ()); - ASSERT_TRUE (node3.latest (rai::test_genesis_key.pub) == send1.hash ()); + ASSERT_TRUE (node1.latest (nano::test_genesis_key.pub) == send1.hash ()); + ASSERT_TRUE (node2.latest (nano::test_genesis_key.pub) == send1.hash ()); + ASSERT_TRUE (node3.latest (nano::test_genesis_key.pub) == send1.hash ()); } // Disabled because it sometimes takes way too long (but still eventually finishes) TEST (node, DISABLED_fork_pre_confirm) { - rai::system system (24000, 3); + nano::system system (24000, 3); auto & node0 (*system.nodes[0]); auto & node1 (*system.nodes[1]); auto & node2 (*system.nodes[2]); - rai::genesis genesis; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key1; + nano::genesis genesis; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key1; system.wallet (1)->insert_adhoc (key1.prv); { auto transaction (system.wallet (1)->wallets.tx_begin (true)); system.wallet (1)->store.representative_set (transaction, key1.pub); } - rai::keypair key2; + nano::keypair key2; system.wallet (2)->insert_adhoc (key2.prv); { auto transaction (system.wallet (2)->wallets.tx_begin (true)); system.wallet (2)->store.representative_set (transaction, key2.pub); } system.deadline_set (30s); - auto block0 (system.wallet (0)->send_action (rai::test_genesis_key.pub, key1.pub, rai::genesis_amount / 3)); + auto block0 (system.wallet (0)->send_action (nano::test_genesis_key.pub, key1.pub, nano::genesis_amount / 3)); ASSERT_NE (nullptr, block0); while (node0.balance (key1.pub) == 0) { ASSERT_NO_ERROR (system.poll ()); } - auto block1 (system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, rai::genesis_amount / 3)); + auto block1 (system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, nano::genesis_amount / 3)); ASSERT_NE (nullptr, block1); while (node0.balance (key2.pub) == 0) { ASSERT_NO_ERROR (system.poll ()); } - rai::keypair key3; - rai::keypair key4; - auto block2 (std::make_shared (rai::test_genesis_key.pub, node0.latest (rai::test_genesis_key.pub), key3.pub, node0.balance (rai::test_genesis_key.pub), 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - auto block3 (std::make_shared (rai::test_genesis_key.pub, node0.latest (rai::test_genesis_key.pub), key4.pub, node0.balance (rai::test_genesis_key.pub), 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + nano::keypair key3; + nano::keypair key4; + auto block2 (std::make_shared (nano::test_genesis_key.pub, node0.latest (nano::test_genesis_key.pub), key3.pub, node0.balance (nano::test_genesis_key.pub), 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); + auto block3 (std::make_shared (nano::test_genesis_key.pub, node0.latest (nano::test_genesis_key.pub), key4.pub, node0.balance (nano::test_genesis_key.pub), 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node0.work_generate_blocking (*block2); node0.work_generate_blocking (*block3); node0.process_active (block2); @@ -1055,8 +1055,8 @@ TEST (node, DISABLED_fork_pre_confirm) system.deadline_set (70s); while (!done) { - done |= node0.latest (rai::test_genesis_key.pub) == block2->hash () && node1.latest (rai::test_genesis_key.pub) == block2->hash () && node2.latest (rai::test_genesis_key.pub) == block2->hash (); - done |= node0.latest (rai::test_genesis_key.pub) == block3->hash () && node1.latest (rai::test_genesis_key.pub) == block3->hash () && node2.latest (rai::test_genesis_key.pub) == block3->hash (); + done |= node0.latest (nano::test_genesis_key.pub) == block2->hash () && node1.latest (nano::test_genesis_key.pub) == block2->hash () && node2.latest (nano::test_genesis_key.pub) == block2->hash (); + done |= node0.latest (nano::test_genesis_key.pub) == block3->hash () && node1.latest (nano::test_genesis_key.pub) == block3->hash () && node2.latest (nano::test_genesis_key.pub) == block3->hash (); ASSERT_NO_ERROR (system.poll ()); } } @@ -1064,17 +1064,17 @@ TEST (node, DISABLED_fork_pre_confirm) // Sometimes hangs on the bootstrap_initiator.bootstrap call TEST (node, DISABLED_fork_stale) { - rai::system system1 (24000, 1); - system1.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::system system2 (24001, 1); + nano::system system1 (24000, 1); + system1.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::system system2 (24001, 1); auto & node1 (*system1.nodes[0]); auto & node2 (*system2.nodes[0]); node2.bootstrap_initiator.bootstrap (node1.network.endpoint ()); - node2.peers.rep_response (node1.network.endpoint (), rai::test_genesis_key.pub, rai::genesis_amount); - rai::genesis genesis; - rai::keypair key1; - rai::keypair key2; - auto send3 (std::make_shared (rai::test_genesis_key.pub, genesis.hash (), rai::test_genesis_key.pub, rai::genesis_amount - rai::Mxrb_ratio, key1.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + node2.peers.rep_response (node1.network.endpoint (), nano::test_genesis_key.pub, nano::genesis_amount); + nano::genesis genesis; + nano::keypair key1; + nano::keypair key2; + auto send3 (std::make_shared (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Mxrb_ratio, key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node1.work_generate_blocking (*send3); node1.process_active (send3); system2.deadline_set (10s); @@ -1083,15 +1083,15 @@ TEST (node, DISABLED_fork_stale) system1.poll (); ASSERT_NO_ERROR (system2.poll ()); } - auto send1 (std::make_shared (rai::test_genesis_key.pub, send3->hash (), rai::test_genesis_key.pub, rai::genesis_amount - 2 * rai::Mxrb_ratio, key1.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::test_genesis_key.pub, send3->hash (), nano::test_genesis_key.pub, nano::genesis_amount - 2 * nano::Mxrb_ratio, key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node1.work_generate_blocking (*send1); - auto send2 (std::make_shared (rai::test_genesis_key.pub, send3->hash (), rai::test_genesis_key.pub, rai::genesis_amount - 2 * rai::Mxrb_ratio, key2.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + auto send2 (std::make_shared (nano::test_genesis_key.pub, send3->hash (), nano::test_genesis_key.pub, nano::genesis_amount - 2 * nano::Mxrb_ratio, key2.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node1.work_generate_blocking (*send2); { auto transaction1 (node1.store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, node1.ledger.process (transaction1, *send1).code); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction1, *send1).code); auto transaction2 (node2.store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, node2.ledger.process (transaction2, *send2).code); + ASSERT_EQ (nano::process_result::progress, node2.ledger.process (transaction2, *send2).code); } node1.process_active (send1); node1.process_active (send2); @@ -1107,13 +1107,13 @@ TEST (node, DISABLED_fork_stale) TEST (node, broadcast_elected) { - rai::system system (24000, 3); + nano::system system (24000, 3); auto node0 (system.nodes[0]); auto node1 (system.nodes[1]); auto node2 (system.nodes[2]); - rai::keypair rep_big; - rai::keypair rep_small; - rai::keypair rep_other; + nano::keypair rep_big; + nano::keypair rep_small; + nano::keypair rep_other; //std::cerr << "Big: " << rep_big.pub.to_account () << std::endl; //std::cerr << "Small: " << rep_small.pub.to_account () << std::endl; //std::cerr << "Other: " << rep_other.pub.to_account () << std::endl; @@ -1121,43 +1121,43 @@ TEST (node, broadcast_elected) auto transaction0 (node0->store.tx_begin (true)); auto transaction1 (node1->store.tx_begin (true)); auto transaction2 (node2->store.tx_begin (true)); - rai::send_block fund_big (node0->ledger.latest (transaction0, rai::test_genesis_key.pub), rep_big.pub, rai::Gxrb_ratio * 5, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::open_block open_big (fund_big.hash (), rep_big.pub, rep_big.pub, rep_big.prv, rep_big.pub, 0); - rai::send_block fund_small (fund_big.hash (), rep_small.pub, rai::Gxrb_ratio * 2, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::open_block open_small (fund_small.hash (), rep_small.pub, rep_small.pub, rep_small.prv, rep_small.pub, 0); - rai::send_block fund_other (fund_small.hash (), rep_other.pub, rai::Gxrb_ratio * 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::open_block open_other (fund_other.hash (), rep_other.pub, rep_other.pub, rep_other.prv, rep_other.pub, 0); + nano::send_block fund_big (node0->ledger.latest (transaction0, nano::test_genesis_key.pub), rep_big.pub, nano::Gxrb_ratio * 5, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::open_block open_big (fund_big.hash (), rep_big.pub, rep_big.pub, rep_big.prv, rep_big.pub, 0); + nano::send_block fund_small (fund_big.hash (), rep_small.pub, nano::Gxrb_ratio * 2, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::open_block open_small (fund_small.hash (), rep_small.pub, rep_small.pub, rep_small.prv, rep_small.pub, 0); + nano::send_block fund_other (fund_small.hash (), rep_other.pub, nano::Gxrb_ratio * 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::open_block open_other (fund_other.hash (), rep_other.pub, rep_other.pub, rep_other.prv, rep_other.pub, 0); node0->work_generate_blocking (fund_big); node0->work_generate_blocking (open_big); node0->work_generate_blocking (fund_small); node0->work_generate_blocking (open_small); - ASSERT_EQ (rai::process_result::progress, node0->ledger.process (transaction0, fund_big).code); - ASSERT_EQ (rai::process_result::progress, node1->ledger.process (transaction1, fund_big).code); - ASSERT_EQ (rai::process_result::progress, node2->ledger.process (transaction2, fund_big).code); - ASSERT_EQ (rai::process_result::progress, node0->ledger.process (transaction0, open_big).code); - ASSERT_EQ (rai::process_result::progress, node1->ledger.process (transaction1, open_big).code); - ASSERT_EQ (rai::process_result::progress, node2->ledger.process (transaction2, open_big).code); - ASSERT_EQ (rai::process_result::progress, node0->ledger.process (transaction0, fund_small).code); - ASSERT_EQ (rai::process_result::progress, node1->ledger.process (transaction1, fund_small).code); - ASSERT_EQ (rai::process_result::progress, node2->ledger.process (transaction2, fund_small).code); - ASSERT_EQ (rai::process_result::progress, node0->ledger.process (transaction0, open_small).code); - ASSERT_EQ (rai::process_result::progress, node1->ledger.process (transaction1, open_small).code); - ASSERT_EQ (rai::process_result::progress, node2->ledger.process (transaction2, open_small).code); - ASSERT_EQ (rai::process_result::progress, node0->ledger.process (transaction0, fund_other).code); - ASSERT_EQ (rai::process_result::progress, node1->ledger.process (transaction1, fund_other).code); - ASSERT_EQ (rai::process_result::progress, node2->ledger.process (transaction2, fund_other).code); - ASSERT_EQ (rai::process_result::progress, node0->ledger.process (transaction0, open_other).code); - ASSERT_EQ (rai::process_result::progress, node1->ledger.process (transaction1, open_other).code); - ASSERT_EQ (rai::process_result::progress, node2->ledger.process (transaction2, open_other).code); + ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, fund_big).code); + ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, fund_big).code); + ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, fund_big).code); + ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, open_big).code); + ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, open_big).code); + ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, open_big).code); + ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, fund_small).code); + ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, fund_small).code); + ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, fund_small).code); + ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, open_small).code); + ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, open_small).code); + ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, open_small).code); + ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, fund_other).code); + ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, fund_other).code); + ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, fund_other).code); + ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, open_other).code); + ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, open_other).code); + ASSERT_EQ (nano::process_result::progress, node2->ledger.process (transaction2, open_other).code); } system.wallet (0)->insert_adhoc (rep_big.prv); system.wallet (1)->insert_adhoc (rep_small.prv); system.wallet (2)->insert_adhoc (rep_other.prv); - auto fork0 (std::make_shared (node2->latest (rai::test_genesis_key.pub), rep_small.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + auto fork0 (std::make_shared (node2->latest (nano::test_genesis_key.pub), rep_small.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node0->work_generate_blocking (*fork0); node0->process_active (fork0); node1->process_active (fork0); - auto fork1 (std::make_shared (node2->latest (rai::test_genesis_key.pub), rep_big.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + auto fork1 (std::make_shared (node2->latest (nano::test_genesis_key.pub), rep_big.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node0->work_generate_blocking (*fork1); system.wallet (2)->insert_adhoc (rep_small.prv); node2->process_active (fork1); @@ -1179,23 +1179,23 @@ TEST (node, broadcast_elected) TEST (node, rep_self_vote) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto node0 (system.nodes[0]); - rai::keypair rep_big; + nano::keypair rep_big; { auto transaction0 (node0->store.tx_begin (true)); - rai::send_block fund_big (node0->ledger.latest (transaction0, rai::test_genesis_key.pub), rep_big.pub, rai::uint128_t ("0xb0000000000000000000000000000000"), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::open_block open_big (fund_big.hash (), rep_big.pub, rep_big.pub, rep_big.prv, rep_big.pub, 0); + nano::send_block fund_big (node0->ledger.latest (transaction0, nano::test_genesis_key.pub), rep_big.pub, nano::uint128_t ("0xb0000000000000000000000000000000"), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::open_block open_big (fund_big.hash (), rep_big.pub, rep_big.pub, rep_big.prv, rep_big.pub, 0); node0->work_generate_blocking (fund_big); node0->work_generate_blocking (open_big); - ASSERT_EQ (rai::process_result::progress, node0->ledger.process (transaction0, fund_big).code); - ASSERT_EQ (rai::process_result::progress, node0->ledger.process (transaction0, open_big).code); + ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, fund_big).code); + ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, open_big).code); } system.wallet (0)->insert_adhoc (rep_big.prv); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto block0 (std::make_shared (node0->latest (rai::test_genesis_key.pub), rep_big.pub, rai::uint128_t ("0x60000000000000000000000000000000"), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto block0 (std::make_shared (node0->latest (nano::test_genesis_key.pub), rep_big.pub, nano::uint128_t ("0x60000000000000000000000000000000"), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node0->work_generate_blocking (*block0); - ASSERT_EQ (rai::process_result::progress, node0->process (*block0).code); + ASSERT_EQ (nano::process_result::progress, node0->process (*block0).code); auto & active (node0->active); active.start (block0); auto existing (active.roots.find (block0->root ())); @@ -1205,23 +1205,23 @@ TEST (node, rep_self_vote) node0->vote_processor.flush (); auto & rep_votes (existing->election->last_votes); ASSERT_EQ (3, rep_votes.size ()); - ASSERT_NE (rep_votes.end (), rep_votes.find (rai::test_genesis_key.pub)); + ASSERT_NE (rep_votes.end (), rep_votes.find (nano::test_genesis_key.pub)); ASSERT_NE (rep_votes.end (), rep_votes.find (rep_big.pub)); } // Bootstrapping shouldn't republish the blocks to the network. TEST (node, DISABLED_bootstrap_no_publish) { - rai::system system0 (24000, 1); - rai::system system1 (24001, 1); + nano::system system0 (24000, 1); + nano::system system1 (24001, 1); auto node0 (system0.nodes[0]); auto node1 (system1.nodes[0]); - rai::keypair key0; + nano::keypair key0; // node0 knows about send0 but node1 doesn't. - rai::send_block send0 (system0.nodes[0]->latest (rai::test_genesis_key.pub), key0.pub, 500, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); + nano::send_block send0 (system0.nodes[0]->latest (nano::test_genesis_key.pub), key0.pub, 500, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); { auto transaction (node0->store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, system0.nodes[0]->ledger.process (transaction, send0).code); + ASSERT_EQ (nano::process_result::progress, system0.nodes[0]->ledger.process (transaction, send0).code); } ASSERT_FALSE (node1->bootstrap_initiator.in_progress ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint ()); @@ -1241,17 +1241,17 @@ TEST (node, DISABLED_bootstrap_no_publish) // Check that an outgoing bootstrap request can push blocks TEST (node, bootstrap_bulk_push) { - rai::system system0 (24000, 1); - rai::system system1 (24001, 1); + nano::system system0 (24000, 1); + nano::system system1 (24001, 1); auto node0 (system0.nodes[0]); auto node1 (system1.nodes[0]); - rai::keypair key0; + nano::keypair key0; // node0 knows about send0 but node1 doesn't. - rai::send_block send0 (system0.nodes[0]->latest (rai::test_genesis_key.pub), key0.pub, 500, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); + nano::send_block send0 (system0.nodes[0]->latest (nano::test_genesis_key.pub), key0.pub, 500, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); node0->work_generate_blocking (send0); { auto transaction (node0->store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, system0.nodes[0]->ledger.process (transaction, send0).code); + ASSERT_EQ (nano::process_result::progress, system0.nodes[0]->ledger.process (transaction, send0).code); } ASSERT_FALSE (node0->bootstrap_initiator.in_progress ()); ASSERT_FALSE (node1->bootstrap_initiator.in_progress ()); @@ -1270,14 +1270,14 @@ TEST (node, bootstrap_bulk_push) // Bootstrapping a forked open block should succeed. TEST (node, bootstrap_fork_open) { - rai::system system0 (24000, 2); - system0.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system0 (24000, 2); + system0.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); auto node0 (system0.nodes[0]); auto node1 (system0.nodes[1]); - rai::keypair key0; - rai::send_block send0 (system0.nodes[0]->latest (rai::test_genesis_key.pub), key0.pub, rai::genesis_amount - 500, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::open_block open0 (send0.hash (), 1, key0.pub, key0.prv, key0.pub, 0); - rai::open_block open1 (send0.hash (), 2, key0.pub, key0.prv, key0.pub, 0); + nano::keypair key0; + nano::send_block send0 (system0.nodes[0]->latest (nano::test_genesis_key.pub), key0.pub, nano::genesis_amount - 500, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::open_block open0 (send0.hash (), 1, key0.pub, key0.prv, key0.pub, 0); + nano::open_block open1 (send0.hash (), 2, key0.pub, key0.prv, key0.pub, 0); node0->work_generate_blocking (send0); node0->work_generate_blocking (open0); node0->work_generate_blocking (open1); @@ -1285,11 +1285,11 @@ TEST (node, bootstrap_fork_open) auto transaction0 (node0->store.tx_begin (true)); auto transaction1 (node1->store.tx_begin (true)); // Both know about send0 - ASSERT_EQ (rai::process_result::progress, node0->ledger.process (transaction0, send0).code); - ASSERT_EQ (rai::process_result::progress, node1->ledger.process (transaction1, send0).code); + ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, send0).code); + ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, send0).code); // They disagree about open0/open1 - ASSERT_EQ (rai::process_result::progress, node0->ledger.process (transaction0, open0).code); - ASSERT_EQ (rai::process_result::progress, node1->ledger.process (transaction1, open1).code); + ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction0, open0).code); + ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction1, open1).code); } ASSERT_FALSE (node1->bootstrap_initiator.in_progress ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint ()); @@ -1305,29 +1305,29 @@ TEST (node, bootstrap_fork_open) // Test that if we create a block that isn't confirmed, we sync. TEST (node, DISABLED_unconfirmed_send) { - rai::system system (24000, 2); + nano::system system (24000, 2); auto & node0 (*system.nodes[0]); auto & node1 (*system.nodes[1]); auto wallet0 (system.wallet (0)); auto wallet1 (system.wallet (1)); - rai::keypair key0; + nano::keypair key0; wallet1->insert_adhoc (key0.prv); - wallet0->insert_adhoc (rai::test_genesis_key.prv); - auto send1 (wallet0->send_action (rai::genesis_account, key0.pub, 2 * rai::Mxrb_ratio)); + wallet0->insert_adhoc (nano::test_genesis_key.prv); + auto send1 (wallet0->send_action (nano::genesis_account, key0.pub, 2 * nano::Mxrb_ratio)); system.deadline_set (10s); - while (node1.balance (key0.pub) != 2 * rai::Mxrb_ratio || node1.bootstrap_initiator.in_progress ()) + while (node1.balance (key0.pub) != 2 * nano::Mxrb_ratio || node1.bootstrap_initiator.in_progress ()) { ASSERT_NO_ERROR (system.poll ()); } auto latest (node1.latest (key0.pub)); - rai::state_block send2 (key0.pub, latest, rai::genesis_account, rai::Mxrb_ratio, rai::genesis_account, key0.prv, key0.pub, node0.work_generate_blocking (latest)); + nano::state_block send2 (key0.pub, latest, nano::genesis_account, nano::Mxrb_ratio, nano::genesis_account, key0.prv, key0.pub, node0.work_generate_blocking (latest)); { auto transaction (node1.store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, node1.ledger.process (transaction, send2).code); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, send2).code); } - auto send3 (wallet1->send_action (key0.pub, rai::genesis_account, rai::Mxrb_ratio)); + auto send3 (wallet1->send_action (key0.pub, nano::genesis_account, nano::Mxrb_ratio)); system.deadline_set (10s); - while (node0.balance (rai::genesis_account) != rai::genesis_amount) + while (node0.balance (nano::genesis_account) != nano::genesis_amount) { ASSERT_NO_ERROR (system.poll ()); } @@ -1336,16 +1336,16 @@ TEST (node, DISABLED_unconfirmed_send) // Test that nodes can track nodes that have rep weight for priority broadcasting TEST (node, rep_list) { - rai::system system (24000, 2); + nano::system system (24000, 2); auto & node0 (*system.nodes[0]); auto & node1 (*system.nodes[1]); auto wallet0 (system.wallet (0)); auto wallet1 (system.wallet (1)); // Node0 has a rep - wallet0->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key1; + wallet0->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key1; // Broadcast a confirm so others should know this is a rep node - wallet0->send_action (rai::test_genesis_key.pub, key1.pub, rai::Mxrb_ratio); + wallet0->send_action (nano::test_genesis_key.pub, key1.pub, nano::Mxrb_ratio); ASSERT_EQ (0, node1.peers.representatives (1).size ()); system.deadline_set (10s); auto done (false); @@ -1369,65 +1369,65 @@ TEST (node, rep_list) // Test that nodes can disable representative voting TEST (node, no_voting) { - rai::system system (24000, 2); + nano::system system (24000, 2); auto & node0 (*system.nodes[0]); auto & node1 (*system.nodes[1]); auto wallet0 (system.wallet (0)); auto wallet1 (system.wallet (1)); node0.config.enable_voting = false; // Node0 has a rep - wallet0->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key1; + wallet0->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key1; wallet1->insert_adhoc (key1.prv); // Broadcast a confirm so others should know this is a rep node - wallet0->send_action (rai::test_genesis_key.pub, key1.pub, rai::Mxrb_ratio); + wallet0->send_action (nano::test_genesis_key.pub, key1.pub, nano::Mxrb_ratio); system.deadline_set (10s); while (!node1.active.roots.empty ()) { ASSERT_NO_ERROR (system.poll ()); } - ASSERT_EQ (0, node1.stats.count (rai::stat::type::message, rai::stat::detail::confirm_ack, rai::stat::dir::in)); + ASSERT_EQ (0, node1.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::in)); } TEST (node, send_callback) { - rai::system system (24000, 1); - rai::keypair key2; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + nano::keypair key2; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key2.prv); system.nodes[0]->config.callback_address = "localhost"; system.nodes[0]->config.callback_port = 8010; system.nodes[0]->config.callback_target = "/"; - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); system.deadline_set (10s); while (system.nodes[0]->balance (key2.pub).is_zero ()) { ASSERT_NO_ERROR (system.poll ()); } - ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (rai::test_genesis_key.pub)); + ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (nano::test_genesis_key.pub)); } // Check that votes get replayed back to nodes if they sent an old sequence number. // This helps representatives continue from their last sequence number if their node is reinitialized and the old sequence number is lost TEST (node, vote_replay) { - rai::system system (24000, 2); - rai::keypair key; - auto open (std::make_shared (0, 1, key.pub, key.prv, key.pub, 0)); + nano::system system (24000, 2); + nano::keypair key; + auto open (std::make_shared (0, 1, key.pub, key.prv, key.pub, 0)); system.nodes[0]->work_generate_blocking (*open); for (auto i (0); i < 11000; ++i) { auto transaction (system.nodes[1]->store.tx_begin ()); - auto vote (system.nodes[1]->store.vote_generate (transaction, rai::test_genesis_key.pub, rai::test_genesis_key.prv, open)); + auto vote (system.nodes[1]->store.vote_generate (transaction, nano::test_genesis_key.pub, nano::test_genesis_key.prv, open)); } { auto transaction (system.nodes[0]->store.tx_begin ()); - std::lock_guard lock (boost::polymorphic_downcast (system.nodes[0]->store_impl.get ())->cache_mutex); - auto vote (system.nodes[0]->store.vote_current (transaction, rai::test_genesis_key.pub)); + std::lock_guard lock (boost::polymorphic_downcast (system.nodes[0]->store_impl.get ())->cache_mutex); + auto vote (system.nodes[0]->store.vote_current (transaction, nano::test_genesis_key.pub)); ASSERT_EQ (nullptr, vote); } - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto block (system.wallet (0)->send_action (rai::test_genesis_key.pub, key.pub, rai::Gxrb_ratio)); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto block (system.wallet (0)->send_action (nano::test_genesis_key.pub, key.pub, nano::Gxrb_ratio)); ASSERT_NE (nullptr, block); auto done (false); system.deadline_set (20s); @@ -1435,8 +1435,8 @@ TEST (node, vote_replay) { auto ec = system.poll (); auto transaction (system.nodes[0]->store.tx_begin ()); - std::lock_guard lock (boost::polymorphic_downcast (system.nodes[0]->store_impl.get ())->cache_mutex); - auto vote (system.nodes[0]->store.vote_current (transaction, rai::test_genesis_key.pub)); + std::lock_guard lock (boost::polymorphic_downcast (system.nodes[0]->store_impl.get ())->cache_mutex); + auto vote (system.nodes[0]->store.vote_current (transaction, nano::test_genesis_key.pub)); done = vote && (vote->sequence >= 10000); ASSERT_NO_ERROR (ec); } @@ -1444,22 +1444,22 @@ TEST (node, vote_replay) TEST (node, balance_observer) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto & node1 (*system.nodes[0]); std::atomic balances (0); - rai::keypair key; - node1.observers.account_balance.add ([&key, &balances](rai::account const & account_a, bool is_pending) { + nano::keypair key; + node1.observers.account_balance.add ([&key, &balances](nano::account const & account_a, bool is_pending) { if (key.pub == account_a && is_pending) { balances++; } - else if (rai::test_genesis_key.pub == account_a && !is_pending) + else if (nano::test_genesis_key.pub == account_a && !is_pending) { balances++; } }); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - system.wallet (0)->send_action (rai::test_genesis_key.pub, key.pub, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + system.wallet (0)->send_action (nano::test_genesis_key.pub, key.pub, 1); system.deadline_set (10s); auto done (false); while (!done) @@ -1473,7 +1473,7 @@ TEST (node, balance_observer) // ASSERT_NE (nullptr, attempt) sometimes fails TEST (node, DISABLED_bootstrap_connection_scaling) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto & node1 (*system.nodes[0]); node1.bootstrap_initiator.bootstrap (); auto attempt (node1.bootstrap_initiator.current_attempt ()); @@ -1496,25 +1496,25 @@ TEST (node, DISABLED_bootstrap_connection_scaling) // Test stat counting at both type and detail levels TEST (node, stat_counting) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto & node1 (*system.nodes[0]); - node1.stats.add (rai::stat::type::ledger, rai::stat::dir::in, 1); - node1.stats.add (rai::stat::type::ledger, rai::stat::dir::in, 5); - node1.stats.inc (rai::stat::type::ledger, rai::stat::dir::in); - node1.stats.inc (rai::stat::type::ledger, rai::stat::detail::send, rai::stat::dir::in); - node1.stats.inc (rai::stat::type::ledger, rai::stat::detail::send, rai::stat::dir::in); - node1.stats.inc (rai::stat::type::ledger, rai::stat::detail::receive, rai::stat::dir::in); - ASSERT_EQ (10, node1.stats.count (rai::stat::type::ledger, rai::stat::dir::in)); - ASSERT_EQ (2, node1.stats.count (rai::stat::type::ledger, rai::stat::detail::send, rai::stat::dir::in)); - ASSERT_EQ (1, node1.stats.count (rai::stat::type::ledger, rai::stat::detail::receive, rai::stat::dir::in)); + node1.stats.add (nano::stat::type::ledger, nano::stat::dir::in, 1); + node1.stats.add (nano::stat::type::ledger, nano::stat::dir::in, 5); + node1.stats.inc (nano::stat::type::ledger, nano::stat::dir::in); + node1.stats.inc (nano::stat::type::ledger, nano::stat::detail::send, nano::stat::dir::in); + node1.stats.inc (nano::stat::type::ledger, nano::stat::detail::send, nano::stat::dir::in); + node1.stats.inc (nano::stat::type::ledger, nano::stat::detail::receive, nano::stat::dir::in); + ASSERT_EQ (10, node1.stats.count (nano::stat::type::ledger, nano::stat::dir::in)); + ASSERT_EQ (2, node1.stats.count (nano::stat::type::ledger, nano::stat::detail::send, nano::stat::dir::in)); + ASSERT_EQ (1, node1.stats.count (nano::stat::type::ledger, nano::stat::detail::receive, nano::stat::dir::in)); } TEST (node, online_reps) { - rai::system system (24000, 2); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 2); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); ASSERT_EQ (system.nodes[1]->config.online_weight_minimum.number (), system.nodes[1]->online_reps.online_stake ()); - system.wallet (0)->send_action (rai::test_genesis_key.pub, rai::test_genesis_key.pub, rai::Gxrb_ratio); + system.wallet (0)->send_action (nano::test_genesis_key.pub, nano::test_genesis_key.pub, nano::Gxrb_ratio); system.deadline_set (10s); while (system.nodes[1]->online_reps.online_stake () == system.nodes[1]->config.online_weight_minimum.number ()) { @@ -1524,11 +1524,11 @@ TEST (node, online_reps) TEST (node, block_confirm) { - rai::system system (24000, 2); - rai::genesis genesis; - rai::keypair key; - system.wallet (1)->insert_adhoc (rai::test_genesis_key.prv); - auto send1 (std::make_shared (rai::test_genesis_key.pub, genesis.hash (), rai::test_genesis_key.pub, rai::genesis_amount - rai::Gxrb_ratio, key.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.nodes[0]->work_generate_blocking (genesis.hash ()))); + nano::system system (24000, 2); + nano::genesis genesis; + nano::keypair key; + system.wallet (1)->insert_adhoc (nano::test_genesis_key.prv); + auto send1 (std::make_shared (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.nodes[0]->work_generate_blocking (genesis.hash ()))); system.nodes[0]->block_processor.add (send1, std::chrono::steady_clock::now ()); system.nodes[1]->block_processor.add (send1, std::chrono::steady_clock::now ()); system.deadline_set (std::chrono::seconds (5)); @@ -1538,14 +1538,14 @@ TEST (node, block_confirm) } ASSERT_TRUE (system.nodes[0]->ledger.block_exists (send1->hash ())); ASSERT_TRUE (system.nodes[1]->ledger.block_exists (send1->hash ())); - auto send2 (std::make_shared (rai::test_genesis_key.pub, send1->hash (), rai::test_genesis_key.pub, rai::genesis_amount - rai::Gxrb_ratio * 2, key.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.nodes[0]->work_generate_blocking (send1->hash ()))); + auto send2 (std::make_shared (nano::test_genesis_key.pub, send1->hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio * 2, key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.nodes[0]->work_generate_blocking (send1->hash ()))); { auto transaction (system.nodes[0]->store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->ledger.process (transaction, *send2).code); } { auto transaction (system.nodes[1]->store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, system.nodes[1]->ledger.process (transaction, *send2).code); + ASSERT_EQ (nano::process_result::progress, system.nodes[1]->ledger.process (transaction, *send2).code); } system.nodes[0]->block_confirm (send2); ASSERT_TRUE (system.nodes[0]->active.confirmed.empty ()); @@ -1558,64 +1558,64 @@ TEST (node, block_confirm) TEST (node, block_arrival) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto & node (*system.nodes[0]); ASSERT_EQ (0, node.block_arrival.arrival.size ()); - rai::block_hash hash1 (1); + nano::block_hash hash1 (1); node.block_arrival.add (hash1); ASSERT_EQ (1, node.block_arrival.arrival.size ()); node.block_arrival.add (hash1); ASSERT_EQ (1, node.block_arrival.arrival.size ()); - rai::block_hash hash2 (2); + nano::block_hash hash2 (2); node.block_arrival.add (hash2); ASSERT_EQ (2, node.block_arrival.arrival.size ()); } TEST (node, block_arrival_size) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto & node (*system.nodes[0]); - auto time (std::chrono::steady_clock::now () - rai::block_arrival::arrival_time_min - std::chrono::seconds (5)); - rai::block_hash hash (0); - for (auto i (0); i < rai::block_arrival::arrival_size_min * 2; ++i) + auto time (std::chrono::steady_clock::now () - nano::block_arrival::arrival_time_min - std::chrono::seconds (5)); + nano::block_hash hash (0); + for (auto i (0); i < nano::block_arrival::arrival_size_min * 2; ++i) { - node.block_arrival.arrival.insert (rai::block_arrival_info{ time, hash }); + node.block_arrival.arrival.insert (nano::block_arrival_info{ time, hash }); ++hash.qwords[0]; } - ASSERT_EQ (rai::block_arrival::arrival_size_min * 2, node.block_arrival.arrival.size ()); + ASSERT_EQ (nano::block_arrival::arrival_size_min * 2, node.block_arrival.arrival.size ()); node.block_arrival.recent (0); - ASSERT_EQ (rai::block_arrival::arrival_size_min, node.block_arrival.arrival.size ()); + ASSERT_EQ (nano::block_arrival::arrival_size_min, node.block_arrival.arrival.size ()); } TEST (node, block_arrival_time) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto & node (*system.nodes[0]); auto time (std::chrono::steady_clock::now ()); - rai::block_hash hash (0); - for (auto i (0); i < rai::block_arrival::arrival_size_min * 2; ++i) + nano::block_hash hash (0); + for (auto i (0); i < nano::block_arrival::arrival_size_min * 2; ++i) { - node.block_arrival.arrival.insert (rai::block_arrival_info{ time, hash }); + node.block_arrival.arrival.insert (nano::block_arrival_info{ time, hash }); ++hash.qwords[0]; } - ASSERT_EQ (rai::block_arrival::arrival_size_min * 2, node.block_arrival.arrival.size ()); + ASSERT_EQ (nano::block_arrival::arrival_size_min * 2, node.block_arrival.arrival.size ()); node.block_arrival.recent (0); - ASSERT_EQ (rai::block_arrival::arrival_size_min * 2, node.block_arrival.arrival.size ()); + ASSERT_EQ (nano::block_arrival::arrival_size_min * 2, node.block_arrival.arrival.size ()); } TEST (node, confirm_quorum) { - rai::system system (24000, 1); - rai::genesis genesis; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + nano::genesis genesis; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); // Put greater than online_weight_minimum in pending so quorum can't be reached - rai::uint128_union new_balance (system.nodes[0]->config.online_weight_minimum.number () - rai::Gxrb_ratio); - auto send1 (std::make_shared (rai::test_genesis_key.pub, genesis.hash (), rai::test_genesis_key.pub, new_balance, rai::test_genesis_key.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.nodes[0]->work_generate_blocking (genesis.hash ()))); + nano::uint128_union new_balance (system.nodes[0]->config.online_weight_minimum.number () - nano::Gxrb_ratio); + auto send1 (std::make_shared (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, new_balance, nano::test_genesis_key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.nodes[0]->work_generate_blocking (genesis.hash ()))); { auto transaction (system.nodes[0]->store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->ledger.process (transaction, *send1).code); } - system.wallet (0)->send_action (rai::test_genesis_key.pub, rai::test_genesis_key.pub, new_balance.number ()); + system.wallet (0)->send_action (nano::test_genesis_key.pub, nano::test_genesis_key.pub, new_balance.number ()); system.deadline_set (10s); while (system.nodes[0]->active.roots.empty ()) { @@ -1627,20 +1627,20 @@ TEST (node, confirm_quorum) ASSERT_FALSE (system.nodes[0]->active.roots.empty ()); auto info (system.nodes[0]->active.roots.find (send1->hash ())); ASSERT_NE (system.nodes[0]->active.roots.end (), info); - done = info->election->announcements > rai::active_transactions::announcement_min; + done = info->election->announcements > nano::active_transactions::announcement_min; ASSERT_NO_ERROR (system.poll ()); } - ASSERT_EQ (0, system.nodes[0]->balance (rai::test_genesis_key.pub)); + ASSERT_EQ (0, system.nodes[0]->balance (nano::test_genesis_key.pub)); } TEST (node, vote_republish) { - rai::system system (24000, 2); - rai::keypair key2; + nano::system system (24000, 2); + nano::keypair key2; system.wallet (1)->insert_adhoc (key2.prv); - rai::genesis genesis; - auto send1 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); - auto send2 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number () * 2, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + nano::genesis genesis; + auto send1 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + auto send2 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number () * 2, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); system.nodes[0]->process_active (send1); system.deadline_set (5s); while (!system.nodes[1]->block (send1->hash ())) @@ -1648,7 +1648,7 @@ TEST (node, vote_republish) ASSERT_NO_ERROR (system.poll ()); } system.nodes[0]->active.publish (send2); - auto vote (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 0, send2)); + auto vote (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 0, send2)); ASSERT_TRUE (system.nodes[0]->active.active (*send1)); ASSERT_TRUE (system.nodes[1]->active.active (*send1)); system.nodes[0]->vote_processor.vote (vote, system.nodes[0]->network.endpoint ()); @@ -1675,12 +1675,12 @@ TEST (node, vote_republish) TEST (node, vote_by_hash_republish) { - rai::system system (24000, 2); - rai::keypair key2; + nano::system system (24000, 2); + nano::keypair key2; system.wallet (1)->insert_adhoc (key2.prv); - rai::genesis genesis; - auto send1 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); - auto send2 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number () * 2, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + nano::genesis genesis; + auto send1 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + auto send2 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number () * 2, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); system.nodes[0]->process_active (send1); system.deadline_set (5s); while (!system.nodes[1]->block (send1->hash ())) @@ -1688,9 +1688,9 @@ TEST (node, vote_by_hash_republish) ASSERT_NO_ERROR (system.poll ()); } system.nodes[0]->active.publish (send2); - std::vector vote_blocks; + std::vector vote_blocks; vote_blocks.push_back (send2->hash ()); - auto vote (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 0, vote_blocks)); + auto vote (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 0, vote_blocks)); ASSERT_TRUE (system.nodes[0]->active.active (*send1)); ASSERT_TRUE (system.nodes[1]->active.active (*send1)); system.nodes[0]->vote_processor.vote (vote, system.nodes[0]->network.endpoint ()); @@ -1717,15 +1717,15 @@ TEST (node, vote_by_hash_republish) TEST (node, vote_by_hash_epoch_block_republish) { - rai::system system (24000, 2); - rai::keypair key2; + nano::system system (24000, 2); + nano::keypair key2; system.wallet (1)->insert_adhoc (key2.prv); - rai::keypair epoch_signer; + nano::keypair epoch_signer; system.nodes[0]->ledger.epoch_signer = epoch_signer.pub; system.nodes[1]->ledger.epoch_signer = epoch_signer.pub; - rai::genesis genesis; - auto send1 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); - auto epoch1 (std::make_shared (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount, system.nodes[0]->ledger.epoch_link, epoch_signer.prv, epoch_signer.pub, system.work.generate (genesis.hash ()))); + nano::genesis genesis; + auto send1 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + auto epoch1 (std::make_shared (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, system.nodes[0]->ledger.epoch_link, epoch_signer.prv, epoch_signer.pub, system.work.generate (genesis.hash ()))); system.nodes[0]->process_active (send1); system.deadline_set (5s); while (!system.nodes[1]->block (send1->hash ())) @@ -1733,9 +1733,9 @@ TEST (node, vote_by_hash_epoch_block_republish) ASSERT_NO_ERROR (system.poll ()); } system.nodes[0]->active.publish (epoch1); - std::vector vote_blocks; + std::vector vote_blocks; vote_blocks.push_back (epoch1->hash ()); - auto vote (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 0, vote_blocks)); + auto vote (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 0, vote_blocks)); ASSERT_TRUE (system.nodes[0]->active.active (*send1)); ASSERT_TRUE (system.nodes[1]->active.active (*send1)); system.nodes[0]->vote_processor.vote (vote, system.nodes[0]->network.endpoint ()); @@ -1753,21 +1753,21 @@ TEST (node, vote_by_hash_epoch_block_republish) TEST (node, fork_invalid_block_signature) { - rai::system system (24000, 2); - rai::keypair key2; - rai::genesis genesis; - auto send1 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); - auto send2 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number () * 2, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); - auto send2_corrupt (std::make_shared (*send2)); - send2_corrupt->signature = rai::signature (123); + nano::system system (24000, 2); + nano::keypair key2; + nano::genesis genesis; + auto send1 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + auto send2 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number () * 2, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + auto send2_corrupt (std::make_shared (*send2)); + send2_corrupt->signature = nano::signature (123); system.nodes[0]->process_active (send1); system.deadline_set (5s); while (!system.nodes[0]->block (send1->hash ())) { ASSERT_NO_ERROR (system.poll ()); } - auto vote (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 0, send2)); - auto vote_corrupt (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 0, send2_corrupt)); + auto vote (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 0, send2)); + auto vote_corrupt (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 0, send2_corrupt)); system.nodes[1]->network.republish_vote (vote_corrupt); ASSERT_NO_ERROR (system.poll ()); system.nodes[1]->network.republish_vote (vote); @@ -1784,13 +1784,13 @@ TEST (node, fork_invalid_block_signature) TEST (node, fork_invalid_block_signature_vote_by_hash) { - rai::system system (24000, 1); - rai::keypair key2; - rai::genesis genesis; - auto send1 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); - auto send2 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number () * 2, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); - auto send2_corrupt (std::make_shared (*send2)); - send2_corrupt->signature = rai::signature (123); + nano::system system (24000, 1); + nano::keypair key2; + nano::genesis genesis; + auto send1 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + auto send2 (std::make_shared (genesis.hash (), key2.pub, std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number () * 2, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + auto send2_corrupt (std::make_shared (*send2)); + send2_corrupt->signature = nano::signature (123); system.nodes[0]->process_active (send1); system.deadline_set (5s); while (!system.nodes[0]->block (send1->hash ())) @@ -1800,9 +1800,9 @@ TEST (node, fork_invalid_block_signature_vote_by_hash) system.nodes[0]->active.publish (send2_corrupt); ASSERT_NO_ERROR (system.poll ()); system.nodes[0]->active.publish (send2); - std::vector vote_blocks; + std::vector vote_blocks; vote_blocks.push_back (send2->hash ()); - auto vote (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 0, vote_blocks)); + auto vote (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 0, vote_blocks)); { auto transaction (system.nodes[0]->store.tx_begin_read ()); std::unique_lock lock (system.nodes[0]->active.mutex); @@ -1821,25 +1821,25 @@ TEST (node, fork_invalid_block_signature_vote_by_hash) TEST (node, block_processor_signatures) { - rai::system system0 (24000, 1); + nano::system system0 (24000, 1); auto & node1 (*system0.nodes[0]); - system0.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::block_hash latest (system0.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::keypair key1; - auto send1 (std::make_shared (rai::test_genesis_key.pub, latest, rai::test_genesis_key.pub, rai::genesis_amount - rai::Gxrb_ratio, key1.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + system0.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::block_hash latest (system0.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::keypair key1; + auto send1 (std::make_shared (nano::test_genesis_key.pub, latest, nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, key1.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node1.work_generate_blocking (*send1); - rai::keypair key2; - auto send2 (std::make_shared (rai::test_genesis_key.pub, send1->hash (), rai::test_genesis_key.pub, rai::genesis_amount - 2 * rai::Gxrb_ratio, key2.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + nano::keypair key2; + auto send2 (std::make_shared (nano::test_genesis_key.pub, send1->hash (), nano::test_genesis_key.pub, nano::genesis_amount - 2 * nano::Gxrb_ratio, key2.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node1.work_generate_blocking (*send2); - rai::keypair key3; - auto send3 (std::make_shared (rai::test_genesis_key.pub, send2->hash (), rai::test_genesis_key.pub, rai::genesis_amount - 3 * rai::Gxrb_ratio, key3.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + nano::keypair key3; + auto send3 (std::make_shared (nano::test_genesis_key.pub, send2->hash (), nano::test_genesis_key.pub, nano::genesis_amount - 3 * nano::Gxrb_ratio, key3.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node1.work_generate_blocking (*send3); // Invalid signature bit - auto send4 (std::make_shared (rai::test_genesis_key.pub, send3->hash (), rai::test_genesis_key.pub, rai::genesis_amount - 4 * rai::Gxrb_ratio, key3.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + auto send4 (std::make_shared (nano::test_genesis_key.pub, send3->hash (), nano::test_genesis_key.pub, nano::genesis_amount - 4 * nano::Gxrb_ratio, key3.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node1.work_generate_blocking (*send4); send4->signature.bytes[32] ^= 0x1; // Invalid signature bit (force) - auto send5 (std::make_shared (rai::test_genesis_key.pub, send3->hash (), rai::test_genesis_key.pub, rai::genesis_amount - 5 * rai::Gxrb_ratio, key3.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + auto send5 (std::make_shared (nano::test_genesis_key.pub, send3->hash (), nano::test_genesis_key.pub, nano::genesis_amount - 5 * nano::Gxrb_ratio, key3.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node1.work_generate_blocking (*send5); send5->signature.bytes[31] ^= 0x1; // Invalid signature to unchecked @@ -1847,12 +1847,12 @@ TEST (node, block_processor_signatures) auto transaction (node1.store.tx_begin_write ()); node1.store.unchecked_put (transaction, send5->previous (), send5); } - auto receive1 (std::make_shared (key1.pub, 0, rai::test_genesis_key.pub, rai::Gxrb_ratio, send1->hash (), key1.prv, key1.pub, 0)); + auto receive1 (std::make_shared (key1.pub, 0, nano::test_genesis_key.pub, nano::Gxrb_ratio, send1->hash (), key1.prv, key1.pub, 0)); node1.work_generate_blocking (*receive1); - auto receive2 (std::make_shared (key2.pub, 0, rai::test_genesis_key.pub, rai::Gxrb_ratio, send2->hash (), key2.prv, key2.pub, 0)); + auto receive2 (std::make_shared (key2.pub, 0, nano::test_genesis_key.pub, nano::Gxrb_ratio, send2->hash (), key2.prv, key2.pub, 0)); node1.work_generate_blocking (*receive2); // Invalid private key - auto receive3 (std::make_shared (key3.pub, 0, rai::test_genesis_key.pub, rai::Gxrb_ratio, send3->hash (), key2.prv, key3.pub, 0)); + auto receive3 (std::make_shared (key3.pub, 0, nano::test_genesis_key.pub, nano::Gxrb_ratio, send3->hash (), key2.prv, key3.pub, 0)); node1.work_generate_blocking (*receive3); node1.process_active (send1); node1.process_active (send2); @@ -1880,17 +1880,17 @@ TEST (node, block_processor_signatures) */ TEST (node, block_processor_reject_state) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto & node (*system.nodes[0]); - rai::genesis genesis; - auto send1 (std::make_shared (rai::test_genesis_key.pub, genesis.hash (), rai::test_genesis_key.pub, rai::genesis_amount - rai::Gxrb_ratio, rai::test_genesis_key.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + nano::genesis genesis; + auto send1 (std::make_shared (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node.work_generate_blocking (*send1); send1->signature.bytes[0] ^= 1; ASSERT_FALSE (node.ledger.block_exists (send1->hash ())); node.process_active (send1); node.block_processor.flush (); ASSERT_FALSE (node.ledger.block_exists (send1->hash ())); - auto send2 (std::make_shared (rai::test_genesis_key.pub, genesis.hash (), rai::test_genesis_key.pub, rai::genesis_amount - 2 * rai::Gxrb_ratio, rai::test_genesis_key.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + auto send2 (std::make_shared (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - 2 * nano::Gxrb_ratio, nano::test_genesis_key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); node.work_generate_blocking (*send2); node.process_active (send2); node.block_processor.flush (); @@ -1899,22 +1899,22 @@ TEST (node, block_processor_reject_state) TEST (node, confirm_back) { - rai::system system (24000, 1); - rai::keypair key; + nano::system system (24000, 1); + nano::keypair key; auto & node (*system.nodes[0]); - rai::genesis genesis; - auto genesis_start_balance (node.balance (rai::test_genesis_key.pub)); - auto send1 (std::make_shared (genesis.hash (), key.pub, genesis_start_balance - 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (genesis.hash ()))); - auto open (std::make_shared (key.pub, 0, key.pub, 1, send1->hash (), key.prv, key.pub, system.work.generate (key.pub))); - auto send2 (std::make_shared (key.pub, open->hash (), key.pub, 0, rai::test_genesis_key.pub, key.prv, key.pub, system.work.generate (open->hash ()))); + nano::genesis genesis; + auto genesis_start_balance (node.balance (nano::test_genesis_key.pub)); + auto send1 (std::make_shared (genesis.hash (), key.pub, genesis_start_balance - 1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (genesis.hash ()))); + auto open (std::make_shared (key.pub, 0, key.pub, 1, send1->hash (), key.prv, key.pub, system.work.generate (key.pub))); + auto send2 (std::make_shared (key.pub, open->hash (), key.pub, 0, nano::test_genesis_key.pub, key.prv, key.pub, system.work.generate (open->hash ()))); node.process_active (send1); node.process_active (open); node.process_active (send2); node.block_processor.flush (); ASSERT_EQ (3, node.active.roots.size ()); - std::vector vote_blocks; + std::vector vote_blocks; vote_blocks.push_back (send2->hash ()); - auto vote (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 0, vote_blocks)); + auto vote (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, 0, vote_blocks)); { auto transaction (node.store.tx_begin_read ()); std::unique_lock lock (node.active.mutex); diff --git a/nano/core_test/peer_container.cpp b/nano/core_test/peer_container.cpp new file mode 100644 index 00000000..20bd487c --- /dev/null +++ b/nano/core_test/peer_container.cpp @@ -0,0 +1,171 @@ +#include +#include + +TEST (peer_container, empty_peers) +{ + nano::peer_container peers (nano::endpoint{}); + auto list (peers.purge_list (std::chrono::steady_clock::now ())); + ASSERT_EQ (0, list.size ()); +} + +TEST (peer_container, no_recontact) +{ + nano::peer_container peers (nano::endpoint{}); + auto observed_peer (0); + auto observed_disconnect (false); + nano::endpoint endpoint1 (boost::asio::ip::address_v6::loopback (), 10000); + ASSERT_EQ (0, peers.size ()); + peers.peer_observer = [&observed_peer](nano::endpoint const &) { ++observed_peer; }; + peers.disconnect_observer = [&observed_disconnect]() { observed_disconnect = true; }; + ASSERT_FALSE (peers.insert (endpoint1, nano::protocol_version)); + ASSERT_EQ (1, peers.size ()); + ASSERT_TRUE (peers.insert (endpoint1, nano::protocol_version)); + auto remaining (peers.purge_list (std::chrono::steady_clock::now () + std::chrono::seconds (5))); + ASSERT_TRUE (remaining.empty ()); + ASSERT_EQ (1, observed_peer); + ASSERT_TRUE (observed_disconnect); +} + +TEST (peer_container, no_self_incoming) +{ + nano::endpoint self (boost::asio::ip::address_v6::loopback (), 10000); + nano::peer_container peers (self); + peers.insert (self, 0); + ASSERT_TRUE (peers.peers.empty ()); +} + +TEST (peer_container, no_self_contacting) +{ + nano::endpoint self (boost::asio::ip::address_v6::loopback (), 10000); + nano::peer_container peers (self); + peers.insert (self, 0); + ASSERT_TRUE (peers.peers.empty ()); +} + +TEST (peer_container, reserved_peers_no_contact) +{ + nano::peer_container peers (nano::endpoint{}); + ASSERT_TRUE (peers.insert (nano::endpoint (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0x00000001)), 10000), 0)); + ASSERT_TRUE (peers.insert (nano::endpoint (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0xc0000201)), 10000), 0)); + ASSERT_TRUE (peers.insert (nano::endpoint (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0xc6336401)), 10000), 0)); + ASSERT_TRUE (peers.insert (nano::endpoint (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0xcb007101)), 10000), 0)); + ASSERT_TRUE (peers.insert (nano::endpoint (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0xe9fc0001)), 10000), 0)); + ASSERT_TRUE (peers.insert (nano::endpoint (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0xf0000001)), 10000), 0)); + ASSERT_TRUE (peers.insert (nano::endpoint (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0xffffffff)), 10000), 0)); + ASSERT_EQ (0, peers.size ()); +} + +TEST (peer_container, split) +{ + nano::peer_container peers (nano::endpoint{}); + auto now (std::chrono::steady_clock::now ()); + nano::endpoint endpoint1 (boost::asio::ip::address_v6::any (), 100); + nano::endpoint endpoint2 (boost::asio::ip::address_v6::any (), 101); + peers.peers.insert (nano::peer_information (endpoint1, now - std::chrono::seconds (1), now)); + peers.peers.insert (nano::peer_information (endpoint2, now + std::chrono::seconds (1), now)); + ASSERT_EQ (2, peers.peers.size ()); + auto list (peers.purge_list (now)); + ASSERT_EQ (1, peers.peers.size ()); + ASSERT_EQ (1, list.size ()); + ASSERT_EQ (endpoint2, list[0].endpoint); +} + +TEST (peer_container, fill_random_clear) +{ + nano::peer_container peers (nano::endpoint{}); + std::array target; + std::fill (target.begin (), target.end (), nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000)); + peers.random_fill (target); + ASSERT_TRUE (std::all_of (target.begin (), target.end (), [](nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::any (), 0); })); +} + +TEST (peer_container, fill_random_full) +{ + nano::peer_container peers (nano::endpoint{}); + for (auto i (0); i < 100; ++i) + { + peers.insert (nano::endpoint (boost::asio::ip::address_v6::loopback (), i), 0); + } + std::array target; + std::fill (target.begin (), target.end (), nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000)); + peers.random_fill (target); + ASSERT_TRUE (std::none_of (target.begin (), target.end (), [](nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000); })); +} + +TEST (peer_container, fill_random_part) +{ + nano::peer_container peers (nano::endpoint{}); + std::array target; + auto half (target.size () / 2); + for (auto i (0); i < half; ++i) + { + peers.insert (nano::endpoint (boost::asio::ip::address_v6::loopback (), i + 1), 0); + } + std::fill (target.begin (), target.end (), nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000)); + peers.random_fill (target); + ASSERT_TRUE (std::none_of (target.begin (), target.begin () + half, [](nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000); })); + ASSERT_TRUE (std::none_of (target.begin (), target.begin () + half, [](nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::loopback (), 0); })); + ASSERT_TRUE (std::all_of (target.begin () + half, target.end (), [](nano::endpoint const & endpoint_a) { return endpoint_a == nano::endpoint (boost::asio::ip::address_v6::any (), 0); })); +} + +TEST (peer_container, list_fanout) +{ + nano::peer_container peers (nano::endpoint{}); + auto list1 (peers.list_fanout ()); + ASSERT_TRUE (list1.empty ()); + for (auto i (0); i < 1000; ++i) + { + ASSERT_FALSE (peers.insert (nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000 + i), nano::protocol_version)); + } + auto list2 (peers.list_fanout ()); + ASSERT_EQ (32, list2.size ()); +} + +TEST (peer_container, rep_weight) +{ + nano::peer_container peers (nano::endpoint{}); + peers.insert (nano::endpoint (boost::asio::ip::address_v6::loopback (), 24001), 0); + ASSERT_TRUE (peers.representatives (1).empty ()); + nano::endpoint endpoint0 (boost::asio::ip::address_v6::loopback (), 24000); + nano::endpoint endpoint1 (boost::asio::ip::address_v6::loopback (), 24002); + nano::endpoint endpoint2 (boost::asio::ip::address_v6::loopback (), 24003); + nano::amount amount (100); + peers.insert (endpoint2, nano::protocol_version); + peers.insert (endpoint0, nano::protocol_version); + peers.insert (endpoint1, nano::protocol_version); + nano::keypair keypair; + peers.rep_response (endpoint0, keypair.pub, amount); + auto reps (peers.representatives (1)); + ASSERT_EQ (1, reps.size ()); + ASSERT_EQ (100, reps[0].rep_weight.number ()); + ASSERT_EQ (keypair.pub, reps[0].probable_rep_account); + ASSERT_EQ (endpoint0, reps[0].endpoint); +} + +// Test to make sure we don't repeatedly send keepalive messages to nodes that aren't responding +TEST (peer_container, reachout) +{ + nano::peer_container peers (nano::endpoint{}); + nano::endpoint endpoint0 (boost::asio::ip::address_v6::loopback (), 24000); + // Make sure having been contacted by them already indicates we shouldn't reach out + peers.insert (endpoint0, nano::protocol_version); + ASSERT_TRUE (peers.reachout (endpoint0)); + nano::endpoint endpoint1 (boost::asio::ip::address_v6::loopback (), 24001); + ASSERT_FALSE (peers.reachout (endpoint1)); + // Reaching out to them once should signal we shouldn't reach out again. + ASSERT_TRUE (peers.reachout (endpoint1)); + // Make sure we don't purge new items + peers.purge_list (std::chrono::steady_clock::now () - std::chrono::seconds (10)); + ASSERT_TRUE (peers.reachout (endpoint1)); + // Make sure we purge old items + peers.purge_list (std::chrono::steady_clock::now () + std::chrono::seconds (10)); + ASSERT_FALSE (peers.reachout (endpoint1)); +} + +TEST (peer_container, depeer) +{ + nano::peer_container peers (nano::endpoint{}); + nano::endpoint endpoint0 (boost::asio::ip::address_v6::loopback (), 24000); + peers.contacted (endpoint0, nano::protocol_version_min - 1); + ASSERT_EQ (0, peers.size ()); +} diff --git a/rai/core_test/processor_service.cpp b/nano/core_test/processor_service.cpp similarity index 64% rename from rai/core_test/processor_service.cpp rename to nano/core_test/processor_service.cpp index 52cd8749..b978963c 100644 --- a/rai/core_test/processor_service.cpp +++ b/nano/core_test/processor_service.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include @@ -9,47 +9,47 @@ TEST (processor_service, bad_send_signature) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; auto transaction (store.tx_begin (true)); store.initialize (transaction, genesis); - rai::account_info info1; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info1)); - rai::keypair key2; - rai::send_block send (info1.head, rai::test_genesis_key.pub, 50, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); + nano::account_info info1; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info1)); + nano::keypair key2; + nano::send_block send (info1.head, nano::test_genesis_key.pub, 50, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); send.signature.bytes[32] ^= 0x1; - ASSERT_EQ (rai::process_result::bad_signature, ledger.process (transaction, send).code); + ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, send).code); } TEST (processor_service, bad_receive_signature) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; auto transaction (store.tx_begin (true)); store.initialize (transaction, genesis); - rai::account_info info1; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info1)); - rai::send_block send (info1.head, rai::test_genesis_key.pub, 50, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::block_hash hash1 (send.hash ()); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send).code); - rai::account_info info2; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info2)); - rai::receive_block receive (hash1, hash1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); + nano::account_info info1; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info1)); + nano::send_block send (info1.head, nano::test_genesis_key.pub, 50, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::block_hash hash1 (send.hash ()); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); + nano::account_info info2; + ASSERT_FALSE (store.account_get (transaction, nano::test_genesis_key.pub, info2)); + nano::receive_block receive (hash1, hash1, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); receive.signature.bytes[32] ^= 0x1; - ASSERT_EQ (rai::process_result::bad_signature, ledger.process (transaction, receive).code); + ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, receive).code); } TEST (alarm, one) { boost::asio::io_context io_ctx; - rai::alarm alarm (io_ctx); + nano::alarm alarm (io_ctx); std::atomic done (false); std::mutex mutex; std::condition_variable condition; @@ -71,7 +71,7 @@ TEST (alarm, one) TEST (alarm, many) { boost::asio::io_context io_ctx; - rai::alarm alarm (io_ctx); + nano::alarm alarm (io_ctx); std::atomic count (0); std::mutex mutex; std::condition_variable condition; @@ -103,7 +103,7 @@ TEST (alarm, many) TEST (alarm, top_execution) { boost::asio::io_context io_ctx; - rai::alarm alarm (io_ctx); + nano::alarm alarm (io_ctx); int value1 (0); int value2 (0); std::mutex mutex; diff --git a/rai/core_test/rpc.cpp b/nano/core_test/rpc.cpp similarity index 70% rename from rai/core_test/rpc.cpp rename to nano/core_test/rpc.cpp index a2399883..93f99d86 100644 --- a/rai/core_test/rpc.cpp +++ b/nano/core_test/rpc.cpp @@ -5,22 +5,22 @@ #include #include #include -#include -#include -#include -#include +#include +#include +#include +#include using namespace std::chrono_literals; class test_response { public: - test_response (boost::property_tree::ptree const & request_a, rai::rpc & rpc_a, boost::asio::io_context & io_ctx) : + test_response (boost::property_tree::ptree const & request_a, nano::rpc & rpc_a, boost::asio::io_context & io_ctx) : request (request_a), sock (io_ctx), status (0) { - sock.async_connect (rai::tcp_endpoint (boost::asio::ip::address_v6::loopback (), rpc_a.config.port), [this](boost::system::error_code const & ec) { + sock.async_connect (nano::tcp_endpoint (boost::asio::ip::address_v6::loopback (), rpc_a.config.port), [this](boost::system::error_code const & ec) { if (!ec) { std::stringstream ostream; @@ -77,12 +77,12 @@ public: TEST (rpc, account_balance) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "account_balance"); - request.put ("account", rai::test_genesis_key.pub.to_account ()); + request.put ("account", nano::test_genesis_key.pub.to_account ()); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); while (response.status == 0) @@ -98,12 +98,12 @@ TEST (rpc, account_balance) TEST (rpc, account_block_count) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "account_block_count"); - request.put ("account", rai::test_genesis_key.pub.to_account ()); + request.put ("account", nano::test_genesis_key.pub.to_account ()); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); while (response.status == 0) @@ -117,8 +117,8 @@ TEST (rpc, account_block_count) TEST (rpc, account_create) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "account_create"); @@ -131,20 +131,20 @@ TEST (rpc, account_create) } ASSERT_EQ (200, response.status); auto account_text (response.json.get ("account")); - rai::uint256_union account; + nano::uint256_union account; ASSERT_FALSE (account.decode_account (account_text)); ASSERT_TRUE (system.wallet (0)->exists (account)); } TEST (rpc, account_weight) { - rai::keypair key; - rai::system system (24000, 1); - rai::block_hash latest (system.nodes[0]->latest (rai::test_genesis_key.pub)); + nano::keypair key; + nano::system system (24000, 1); + nano::block_hash latest (system.nodes[0]->latest (nano::test_genesis_key.pub)); auto & node1 (*system.nodes[0]); - rai::change_block block (latest, key.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, node1.work_generate_blocking (latest)); - ASSERT_EQ (rai::process_result::progress, node1.process (block).code); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::change_block block (latest, key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, node1.work_generate_blocking (latest)); + ASSERT_EQ (nano::process_result::progress, node1.process (block).code); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "account_weight"); @@ -162,16 +162,16 @@ TEST (rpc, account_weight) TEST (rpc, wallet_contains) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); boost::property_tree::ptree request; std::string wallet; system.nodes[0]->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "wallet_contains"); - request.put ("account", rai::test_genesis_key.pub.to_account ()); + request.put ("account", nano::test_genesis_key.pub.to_account ()); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); while (response.status == 0) @@ -185,15 +185,15 @@ TEST (rpc, wallet_contains) TEST (rpc, wallet_doesnt_contain) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; std::string wallet; system.nodes[0]->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "wallet_contains"); - request.put ("account", rai::test_genesis_key.pub.to_account ()); + request.put ("account", nano::test_genesis_key.pub.to_account ()); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); while (response.status == 0) @@ -207,13 +207,13 @@ TEST (rpc, wallet_doesnt_contain) TEST (rpc, validate_account_number) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); boost::property_tree::ptree request; request.put ("action", "validate_account_number"); - request.put ("account", rai::test_genesis_key.pub.to_account ()); + request.put ("account", nano::test_genesis_key.pub.to_account ()); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); while (response.status == 0) @@ -226,13 +226,13 @@ TEST (rpc, validate_account_number) TEST (rpc, validate_account_invalid) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); std::string account; - rai::test_genesis_key.pub.encode_account (account); + nano::test_genesis_key.pub.encode_account (account); account[0] ^= 0x1; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); boost::property_tree::ptree request; request.put ("action", "validate_account_number"); request.put ("account", account); @@ -249,21 +249,21 @@ TEST (rpc, validate_account_invalid) TEST (rpc, send) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); boost::property_tree::ptree request; std::string wallet; system.nodes[0]->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "send"); - request.put ("source", rai::test_genesis_key.pub.to_account ()); - request.put ("destination", rai::test_genesis_key.pub.to_account ()); + request.put ("source", nano::test_genesis_key.pub.to_account ()); + request.put ("destination", nano::test_genesis_key.pub.to_account ()); request.put ("amount", "100"); boost::thread thread2 ([&system]() { system.deadline_set (10s); - while (system.nodes[0]->balance (rai::test_genesis_key.pub) == rai::genesis_amount) + while (system.nodes[0]->balance (nano::test_genesis_key.pub) == nano::genesis_amount) { ASSERT_NO_ERROR (system.poll ()); } @@ -276,25 +276,25 @@ TEST (rpc, send) } ASSERT_EQ (200, response.status); std::string block_text (response.json.get ("block")); - rai::block_hash block; + nano::block_hash block; ASSERT_FALSE (block.decode_hex (block_text)); ASSERT_TRUE (system.nodes[0]->ledger.block_exists (block)); - ASSERT_EQ (system.nodes[0]->latest (rai::test_genesis_key.pub), block); + ASSERT_EQ (system.nodes[0]->latest (nano::test_genesis_key.pub), block); thread2.join (); } TEST (rpc, send_fail) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; std::string wallet; system.nodes[0]->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "send"); - request.put ("source", rai::test_genesis_key.pub.to_account ()); - request.put ("destination", rai::test_genesis_key.pub.to_account ()); + request.put ("source", nano::test_genesis_key.pub.to_account ()); + request.put ("destination", nano::test_genesis_key.pub.to_account ()); request.put ("amount", "100"); std::atomic done (false); boost::thread thread2 ([&system, &done]() { @@ -317,17 +317,17 @@ TEST (rpc, send_fail) TEST (rpc, send_work) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); boost::property_tree::ptree request; std::string wallet; system.nodes[0]->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "send"); - request.put ("source", rai::test_genesis_key.pub.to_account ()); - request.put ("destination", rai::test_genesis_key.pub.to_account ()); + request.put ("source", nano::test_genesis_key.pub.to_account ()); + request.put ("destination", nano::test_genesis_key.pub.to_account ()); request.put ("amount", "100"); request.put ("work", "1"); test_response response (request, rpc, system.io_ctx); @@ -338,7 +338,7 @@ TEST (rpc, send_work) } ASSERT_EQ (response.json.get ("error"), "Invalid work"); request.erase ("work"); - request.put ("work", rai::to_string_hex (system.nodes[0]->work_generate_blocking (system.nodes[0]->latest (rai::test_genesis_key.pub)))); + request.put ("work", nano::to_string_hex (system.nodes[0]->work_generate_blocking (system.nodes[0]->latest (nano::test_genesis_key.pub)))); test_response response2 (request, rpc, system.io_ctx); system.deadline_set (10s); while (response2.status == 0) @@ -347,26 +347,26 @@ TEST (rpc, send_work) } ASSERT_EQ (200, response2.status); std::string block_text (response2.json.get ("block")); - rai::block_hash block; + nano::block_hash block; ASSERT_FALSE (block.decode_hex (block_text)); ASSERT_TRUE (system.nodes[0]->ledger.block_exists (block)); - ASSERT_EQ (system.nodes[0]->latest (rai::test_genesis_key.pub), block); + ASSERT_EQ (system.nodes[0]->latest (nano::test_genesis_key.pub), block); } TEST (rpc, send_idempotent) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); boost::property_tree::ptree request; std::string wallet; system.nodes[0]->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "send"); - request.put ("source", rai::test_genesis_key.pub.to_account ()); - request.put ("destination", rai::account (0).to_account ()); - request.put ("amount", (rai::genesis_amount - (rai::genesis_amount / 4)).convert_to ()); + request.put ("source", nano::test_genesis_key.pub.to_account ()); + request.put ("destination", nano::account (0).to_account ()); + request.put ("amount", (nano::genesis_amount - (nano::genesis_amount / 4)).convert_to ()); request.put ("id", "123abc"); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); @@ -376,10 +376,10 @@ TEST (rpc, send_idempotent) } ASSERT_EQ (200, response.status); std::string block_text (response.json.get ("block")); - rai::block_hash block; + nano::block_hash block; ASSERT_FALSE (block.decode_hex (block_text)); ASSERT_TRUE (system.nodes[0]->ledger.block_exists (block)); - ASSERT_EQ (system.nodes[0]->balance (rai::test_genesis_key.pub), rai::genesis_amount / 4); + ASSERT_EQ (system.nodes[0]->balance (nano::test_genesis_key.pub), nano::genesis_amount / 4); test_response response2 (request, rpc, system.io_ctx); system.deadline_set (5s); while (response2.status == 0) @@ -389,7 +389,7 @@ TEST (rpc, send_idempotent) ASSERT_EQ (200, response2.status); ASSERT_EQ ("", response2.json.get ("error", "")); ASSERT_EQ (block_text, response2.json.get ("block")); - ASSERT_EQ (system.nodes[0]->balance (rai::test_genesis_key.pub), rai::genesis_amount / 4); + ASSERT_EQ (system.nodes[0]->balance (nano::test_genesis_key.pub), nano::genesis_amount / 4); request.erase ("id"); request.put ("id", "456def"); test_response response3 (request, rpc, system.io_ctx); @@ -404,8 +404,8 @@ TEST (rpc, send_idempotent) TEST (rpc, stop) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "stop"); @@ -420,10 +420,10 @@ TEST (rpc, stop) TEST (rpc, wallet_add) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); - rai::keypair key1; + nano::keypair key1; std::string key_text; key1.prv.data.encode_hex (key_text); boost::property_tree::ptree request; @@ -446,8 +446,8 @@ TEST (rpc, wallet_add) TEST (rpc, wallet_password_valid) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; std::string wallet; @@ -467,8 +467,8 @@ TEST (rpc, wallet_password_valid) TEST (rpc, wallet_password_change) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; std::string wallet; @@ -495,8 +495,8 @@ TEST (rpc, wallet_password_change) TEST (rpc, wallet_password_enter) { - rai::system system (24000, 1); - rai::raw_key password_l; + nano::system system (24000, 1); + nano::raw_key password_l; password_l.data.clear (); system.deadline_set (10s); while (password_l.data == 0) @@ -504,7 +504,7 @@ TEST (rpc, wallet_password_enter) ASSERT_NO_ERROR (system.poll ()); system.wallet (0)->store.password.value (password_l); } - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; std::string wallet; @@ -525,8 +525,8 @@ TEST (rpc, wallet_password_enter) TEST (rpc, wallet_representative) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; std::string wallet; @@ -541,19 +541,19 @@ TEST (rpc, wallet_representative) } ASSERT_EQ (200, response.status); std::string account_text1 (response.json.get ("representative")); - ASSERT_EQ (account_text1, rai::genesis_account.to_account ()); + ASSERT_EQ (account_text1, nano::genesis_account.to_account ()); } TEST (rpc, wallet_representative_set) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; std::string wallet; system.nodes[0]->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); - rai::keypair key; + nano::keypair key; request.put ("action", "wallet_representative_set"); request.put ("representative", key.pub.to_account ()); test_response response (request, rpc, system.io_ctx); @@ -569,11 +569,11 @@ TEST (rpc, wallet_representative_set) TEST (rpc, account_list) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); - rai::keypair key2; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::keypair key2; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key2.prv); boost::property_tree::ptree request; std::string wallet; @@ -588,11 +588,11 @@ TEST (rpc, account_list) } ASSERT_EQ (200, response.status); auto & accounts_node (response.json.get_child ("accounts")); - std::vector accounts; + std::vector accounts; for (auto i (accounts_node.begin ()), j (accounts_node.end ()); i != j; ++i) { auto account (i->second.get ("")); - rai::uint256_union number; + nano::uint256_union number; ASSERT_FALSE (number.decode_account (account)); accounts.push_back (number); } @@ -605,10 +605,10 @@ TEST (rpc, account_list) TEST (rpc, wallet_key_valid) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); boost::property_tree::ptree request; std::string wallet; system.nodes[0]->wallets.items.begin ()->first.encode_hex (wallet); @@ -627,8 +627,8 @@ TEST (rpc, wallet_key_valid) TEST (rpc, wallet_create) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "wallet_create"); @@ -640,17 +640,17 @@ TEST (rpc, wallet_create) } ASSERT_EQ (200, response.status); std::string wallet_text (response.json.get ("wallet")); - rai::uint256_union wallet_id; + nano::uint256_union wallet_id; ASSERT_FALSE (wallet_id.decode_hex (wallet_text)); ASSERT_NE (system.nodes[0]->wallets.items.end (), system.nodes[0]->wallets.items.find (wallet_id)); } TEST (rpc, wallet_export) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); boost::property_tree::ptree request; request.put ("action", "wallet_export"); request.put ("wallet", system.nodes[0]->wallets.items.begin ()->first.to_string ()); @@ -664,19 +664,19 @@ TEST (rpc, wallet_export) std::string wallet_json (response.json.get ("json")); bool error (false); auto transaction (system.nodes[0]->wallets.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store store (error, kdf, transaction, rai::genesis_account, 1, "0", wallet_json); + nano::kdf kdf; + nano::wallet_store store (error, kdf, transaction, nano::genesis_account, 1, "0", wallet_json); ASSERT_FALSE (error); - ASSERT_TRUE (store.exists (transaction, rai::test_genesis_key.pub)); + ASSERT_TRUE (store.exists (transaction, nano::test_genesis_key.pub)); } TEST (rpc, wallet_destroy) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto wallet_id (system.nodes[0]->wallets.items.begin ()->first); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); boost::property_tree::ptree request; request.put ("action", "wallet_destroy"); request.put ("wallet", wallet_id.to_string ()); @@ -692,14 +692,14 @@ TEST (rpc, wallet_destroy) TEST (rpc, account_move) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto wallet_id (system.nodes[0]->wallets.items.begin ()->first); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); auto destination (system.wallet (0)); - rai::keypair key; - destination->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair source_id; + nano::keypair key; + destination->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair source_id; auto source (system.nodes[0]->wallets.create (source_id.pub)); source->insert_adhoc (key.prv); boost::property_tree::ptree request; @@ -720,19 +720,19 @@ TEST (rpc, account_move) ASSERT_EQ (200, response.status); ASSERT_EQ ("1", response.json.get ("moved")); ASSERT_TRUE (destination->exists (key.pub)); - ASSERT_TRUE (destination->exists (rai::test_genesis_key.pub)); + ASSERT_TRUE (destination->exists (nano::test_genesis_key.pub)); auto transaction (system.nodes[0]->wallets.tx_begin ()); ASSERT_EQ (source->store.end (), source->store.begin (transaction)); } TEST (rpc, block) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "block"); - request.put ("hash", system.nodes[0]->latest (rai::genesis_account).to_string ()); + request.put ("hash", system.nodes[0]->latest (nano::genesis_account).to_string ()); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); while (response.status == 0) @@ -746,10 +746,10 @@ TEST (rpc, block) TEST (rpc, block_account) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); - rai::genesis genesis; + nano::genesis genesis; boost::property_tree::ptree request; request.put ("action", "block_account"); request.put ("hash", genesis.hash ().to_string ()); @@ -761,20 +761,20 @@ TEST (rpc, block_account) } ASSERT_EQ (200, response.status); std::string account_text (response.json.get ("account")); - rai::account account; + nano::account account; ASSERT_FALSE (account.decode_account (account_text)); } TEST (rpc, chain) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key; - auto genesis (system.nodes[0]->latest (rai::test_genesis_key.pub)); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key; + auto genesis (system.nodes[0]->latest (nano::test_genesis_key.pub)); ASSERT_FALSE (genesis.is_zero ()); - auto block (system.wallet (0)->send_action (rai::test_genesis_key.pub, key.pub, 1)); + auto block (system.wallet (0)->send_action (nano::test_genesis_key.pub, key.pub, 1)); ASSERT_NE (nullptr, block); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "chain"); @@ -788,10 +788,10 @@ TEST (rpc, chain) } ASSERT_EQ (200, response.status); auto & blocks_node (response.json.get_child ("blocks")); - std::vector blocks; + std::vector blocks; for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i) { - blocks.push_back (rai::block_hash (i->second.get (""))); + blocks.push_back (nano::block_hash (i->second.get (""))); } ASSERT_EQ (2, blocks.size ()); ASSERT_EQ (block->hash (), blocks[0]); @@ -800,14 +800,14 @@ TEST (rpc, chain) TEST (rpc, chain_limit) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key; - auto genesis (system.nodes[0]->latest (rai::test_genesis_key.pub)); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key; + auto genesis (system.nodes[0]->latest (nano::test_genesis_key.pub)); ASSERT_FALSE (genesis.is_zero ()); - auto block (system.wallet (0)->send_action (rai::test_genesis_key.pub, key.pub, 1)); + auto block (system.wallet (0)->send_action (nano::test_genesis_key.pub, key.pub, 1)); ASSERT_NE (nullptr, block); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "chain"); @@ -821,10 +821,10 @@ TEST (rpc, chain_limit) } ASSERT_EQ (200, response.status); auto & blocks_node (response.json.get_child ("blocks")); - std::vector blocks; + std::vector blocks; for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i) { - blocks.push_back (rai::block_hash (i->second.get (""))); + blocks.push_back (nano::block_hash (i->second.get (""))); } ASSERT_EQ (1, blocks.size ()); ASSERT_EQ (block->hash (), blocks[0]); @@ -832,23 +832,23 @@ TEST (rpc, chain_limit) TEST (rpc, frontier) { - rai::system system (24000, 1); - std::unordered_map source; + nano::system system (24000, 1); + std::unordered_map source; { auto transaction (system.nodes[0]->wallets.tx_begin (true)); for (auto i (0); i < 1000; ++i) { - rai::keypair key; + nano::keypair key; source[key.pub] = key.prv.data; - system.nodes[0]->store.account_put (transaction, key.pub, rai::account_info (key.prv.data, 0, 0, 0, 0, 0, rai::epoch::epoch_0)); + system.nodes[0]->store.account_put (transaction, key.pub, nano::account_info (key.prv.data, 0, 0, 0, 0, 0, nano::epoch::epoch_0)); } } - rai::keypair key; - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::keypair key; + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "frontiers"); - request.put ("account", rai::account (0).to_account ()); + request.put ("account", nano::account (0).to_account ()); request.put ("count", std::to_string (std::numeric_limits::max ())); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); @@ -858,38 +858,38 @@ TEST (rpc, frontier) } ASSERT_EQ (200, response.status); auto & frontiers_node (response.json.get_child ("frontiers")); - std::unordered_map frontiers; + std::unordered_map frontiers; for (auto i (frontiers_node.begin ()), j (frontiers_node.end ()); i != j; ++i) { - rai::account account; + nano::account account; account.decode_account (i->first); - rai::block_hash frontier; + nano::block_hash frontier; frontier.decode_hex (i->second.get ("")); frontiers[account] = frontier; } - ASSERT_EQ (1, frontiers.erase (rai::test_genesis_key.pub)); + ASSERT_EQ (1, frontiers.erase (nano::test_genesis_key.pub)); ASSERT_EQ (source, frontiers); } TEST (rpc, frontier_limited) { - rai::system system (24000, 1); - std::unordered_map source; + nano::system system (24000, 1); + std::unordered_map source; { auto transaction (system.nodes[0]->wallets.tx_begin (true)); for (auto i (0); i < 1000; ++i) { - rai::keypair key; + nano::keypair key; source[key.pub] = key.prv.data; - system.nodes[0]->store.account_put (transaction, key.pub, rai::account_info (key.prv.data, 0, 0, 0, 0, 0, rai::epoch::epoch_0)); + system.nodes[0]->store.account_put (transaction, key.pub, nano::account_info (key.prv.data, 0, 0, 0, 0, 0, nano::epoch::epoch_0)); } } - rai::keypair key; - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::keypair key; + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "frontiers"); - request.put ("account", rai::account (0).to_account ()); + request.put ("account", nano::account (0).to_account ()); request.put ("count", std::to_string (100)); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); @@ -904,19 +904,19 @@ TEST (rpc, frontier_limited) TEST (rpc, frontier_startpoint) { - rai::system system (24000, 1); - std::unordered_map source; + nano::system system (24000, 1); + std::unordered_map source; { auto transaction (system.nodes[0]->wallets.tx_begin (true)); for (auto i (0); i < 1000; ++i) { - rai::keypair key; + nano::keypair key; source[key.pub] = key.prv.data; - system.nodes[0]->store.account_put (transaction, key.pub, rai::account_info (key.prv.data, 0, 0, 0, 0, 0, rai::epoch::epoch_0)); + system.nodes[0]->store.account_put (transaction, key.pub, nano::account_info (key.prv.data, 0, 0, 0, 0, 0, nano::epoch::epoch_0)); } } - rai::keypair key; - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::keypair key; + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "frontiers"); @@ -936,26 +936,26 @@ TEST (rpc, frontier_startpoint) TEST (rpc, history) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto change (system.wallet (0)->change_action (rai::test_genesis_key.pub, rai::test_genesis_key.pub)); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto change (system.wallet (0)->change_action (nano::test_genesis_key.pub, nano::test_genesis_key.pub)); ASSERT_NE (nullptr, change); - auto send (system.wallet (0)->send_action (rai::test_genesis_key.pub, rai::test_genesis_key.pub, system.nodes[0]->config.receive_minimum.number ())); + auto send (system.wallet (0)->send_action (nano::test_genesis_key.pub, nano::test_genesis_key.pub, system.nodes[0]->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); - auto receive (system.wallet (0)->receive_action (*send, rai::test_genesis_key.pub, system.nodes[0]->config.receive_minimum.number ())); + auto receive (system.wallet (0)->receive_action (*send, nano::test_genesis_key.pub, system.nodes[0]->config.receive_minimum.number ())); ASSERT_NE (nullptr, receive); auto node0 (system.nodes[0]); - rai::genesis genesis; - rai::state_block usend (rai::genesis_account, node0->latest (rai::genesis_account), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::state_block ureceive (rai::genesis_account, usend.hash (), rai::genesis_account, rai::genesis_amount, usend.hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::state_block uchange (rai::genesis_account, ureceive.hash (), rai::keypair ().pub, rai::genesis_amount, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); + nano::genesis genesis; + nano::state_block usend (nano::genesis_account, node0->latest (nano::genesis_account), nano::genesis_account, nano::genesis_amount - nano::Gxrb_ratio, nano::genesis_account, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::state_block ureceive (nano::genesis_account, usend.hash (), nano::genesis_account, nano::genesis_amount, usend.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + nano::state_block uchange (nano::genesis_account, ureceive.hash (), nano::keypair ().pub, nano::genesis_amount, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); { auto transaction (node0->wallets.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, node0->ledger.process (transaction, usend).code); - ASSERT_EQ (rai::process_result::progress, node0->ledger.process (transaction, ureceive).code); - ASSERT_EQ (rai::process_result::progress, node0->ledger.process (transaction, uchange).code); + ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, usend).code); + ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, ureceive).code); + ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, uchange).code); } - rai::rpc rpc (system.io_ctx, *node0, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *node0, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "history"); @@ -977,38 +977,38 @@ TEST (rpc, history) ASSERT_EQ (5, history_l.size ()); ASSERT_EQ ("receive", std::get<0> (history_l[0])); ASSERT_EQ (ureceive.hash ().to_string (), std::get<3> (history_l[0])); - ASSERT_EQ (rai::test_genesis_key.pub.to_account (), std::get<1> (history_l[0])); - ASSERT_EQ (rai::Gxrb_ratio.convert_to (), std::get<2> (history_l[0])); + ASSERT_EQ (nano::test_genesis_key.pub.to_account (), std::get<1> (history_l[0])); + ASSERT_EQ (nano::Gxrb_ratio.convert_to (), std::get<2> (history_l[0])); ASSERT_EQ (5, history_l.size ()); ASSERT_EQ ("send", std::get<0> (history_l[1])); ASSERT_EQ (usend.hash ().to_string (), std::get<3> (history_l[1])); - ASSERT_EQ (rai::test_genesis_key.pub.to_account (), std::get<1> (history_l[1])); - ASSERT_EQ (rai::Gxrb_ratio.convert_to (), std::get<2> (history_l[1])); + ASSERT_EQ (nano::test_genesis_key.pub.to_account (), std::get<1> (history_l[1])); + ASSERT_EQ (nano::Gxrb_ratio.convert_to (), std::get<2> (history_l[1])); ASSERT_EQ ("receive", std::get<0> (history_l[2])); - ASSERT_EQ (rai::test_genesis_key.pub.to_account (), std::get<1> (history_l[2])); + ASSERT_EQ (nano::test_genesis_key.pub.to_account (), std::get<1> (history_l[2])); ASSERT_EQ (system.nodes[0]->config.receive_minimum.to_string_dec (), std::get<2> (history_l[2])); ASSERT_EQ (receive->hash ().to_string (), std::get<3> (history_l[2])); ASSERT_EQ ("send", std::get<0> (history_l[3])); - ASSERT_EQ (rai::test_genesis_key.pub.to_account (), std::get<1> (history_l[3])); + ASSERT_EQ (nano::test_genesis_key.pub.to_account (), std::get<1> (history_l[3])); ASSERT_EQ (system.nodes[0]->config.receive_minimum.to_string_dec (), std::get<2> (history_l[3])); ASSERT_EQ (send->hash ().to_string (), std::get<3> (history_l[3])); ASSERT_EQ ("receive", std::get<0> (history_l[4])); - ASSERT_EQ (rai::test_genesis_key.pub.to_account (), std::get<1> (history_l[4])); - ASSERT_EQ (rai::genesis_amount.convert_to (), std::get<2> (history_l[4])); + ASSERT_EQ (nano::test_genesis_key.pub.to_account (), std::get<1> (history_l[4])); + ASSERT_EQ (nano::genesis_amount.convert_to (), std::get<2> (history_l[4])); ASSERT_EQ (genesis.hash ().to_string (), std::get<3> (history_l[4])); } TEST (rpc, history_count) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto change (system.wallet (0)->change_action (rai::test_genesis_key.pub, rai::test_genesis_key.pub)); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto change (system.wallet (0)->change_action (nano::test_genesis_key.pub, nano::test_genesis_key.pub)); ASSERT_NE (nullptr, change); - auto send (system.wallet (0)->send_action (rai::test_genesis_key.pub, rai::test_genesis_key.pub, system.nodes[0]->config.receive_minimum.number ())); + auto send (system.wallet (0)->send_action (nano::test_genesis_key.pub, nano::test_genesis_key.pub, system.nodes[0]->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); - auto receive (system.wallet (0)->receive_action (*send, rai::test_genesis_key.pub, system.nodes[0]->config.receive_minimum.number ())); + auto receive (system.wallet (0)->receive_action (*send, nano::test_genesis_key.pub, system.nodes[0]->config.receive_minimum.number ())); ASSERT_NE (nullptr, receive); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "history"); @@ -1027,12 +1027,12 @@ TEST (rpc, history_count) TEST (rpc, process_block) { - rai::system system (24000, 1); - rai::keypair key; - auto latest (system.nodes[0]->latest (rai::test_genesis_key.pub)); + nano::system system (24000, 1); + nano::keypair key; + auto latest (system.nodes[0]->latest (nano::test_genesis_key.pub)); auto & node1 (*system.nodes[0]); - rai::send_block send (latest, key.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, node1.work_generate_blocking (latest)); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::send_block send (latest, key.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, node1.work_generate_blocking (latest)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "process"); @@ -1047,7 +1047,7 @@ TEST (rpc, process_block) } ASSERT_EQ (200, response.status); system.deadline_set (10s); - while (system.nodes[0]->latest (rai::test_genesis_key.pub) != send.hash ()) + while (system.nodes[0]->latest (nano::test_genesis_key.pub) != send.hash ()) { ASSERT_NO_ERROR (system.poll ()); } @@ -1057,13 +1057,13 @@ TEST (rpc, process_block) TEST (rpc, process_block_no_work) { - rai::system system (24000, 1); - rai::keypair key; - auto latest (system.nodes[0]->latest (rai::test_genesis_key.pub)); + nano::system system (24000, 1); + nano::keypair key; + auto latest (system.nodes[0]->latest (nano::test_genesis_key.pub)); auto & node1 (*system.nodes[0]); - rai::send_block send (latest, key.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, node1.work_generate_blocking (latest)); + nano::send_block send (latest, key.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, node1.work_generate_blocking (latest)); send.block_work_set (0); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "process"); @@ -1082,12 +1082,12 @@ TEST (rpc, process_block_no_work) TEST (rpc, process_republish) { - rai::system system (24000, 2); - rai::keypair key; - auto latest (system.nodes[0]->latest (rai::test_genesis_key.pub)); + nano::system system (24000, 2); + nano::keypair key; + auto latest (system.nodes[0]->latest (nano::test_genesis_key.pub)); auto & node1 (*system.nodes[0]); - rai::send_block send (latest, key.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, node1.work_generate_blocking (latest)); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::send_block send (latest, key.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, node1.work_generate_blocking (latest)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "process"); @@ -1102,7 +1102,7 @@ TEST (rpc, process_republish) } ASSERT_EQ (200, response.status); system.deadline_set (10s); - while (system.nodes[1]->latest (rai::test_genesis_key.pub) != send.hash ()) + while (system.nodes[1]->latest (nano::test_genesis_key.pub) != send.hash ()) { ASSERT_NO_ERROR (system.poll ()); } @@ -1110,12 +1110,12 @@ TEST (rpc, process_republish) TEST (rpc, keepalive) { - rai::system system (24000, 1); - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); + nano::system system (24000, 1); + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); node1->start (); system.nodes.push_back (node1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "keepalive"); @@ -1143,13 +1143,13 @@ TEST (rpc, keepalive) TEST (rpc, payment_init) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto node1 (system.nodes[0]); - rai::keypair wallet_id; + nano::keypair wallet_id; auto wallet (node1->wallets.create (wallet_id.pub)); ASSERT_TRUE (node1->wallets.items.find (wallet_id.pub) != node1->wallets.items.end ()); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "payment_init"); @@ -1166,13 +1166,13 @@ TEST (rpc, payment_init) TEST (rpc, payment_begin_end) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto node1 (system.nodes[0]); - rai::keypair wallet_id; + nano::keypair wallet_id; auto wallet (node1->wallets.create (wallet_id.pub)); ASSERT_TRUE (node1->wallets.items.find (wallet_id.pub) != node1->wallets.items.end ()); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; request1.put ("action", "payment_begin"); @@ -1185,22 +1185,22 @@ TEST (rpc, payment_begin_end) } ASSERT_EQ (200, response1.status); auto account_text (response1.json.get ("account")); - rai::uint256_union account; + nano::uint256_union account; ASSERT_FALSE (account.decode_account (account_text)); ASSERT_TRUE (wallet->exists (account)); - rai::block_hash root1; + nano::block_hash root1; { auto transaction (node1->store.tx_begin ()); root1 = node1->ledger.latest_root (transaction, account); } uint64_t work (0); - while (!rai::work_validate (root1, work)) + while (!nano::work_validate (root1, work)) { ++work; ASSERT_LT (work, 50); } system.deadline_set (10s); - while (rai::work_validate (root1, work)) + while (nano::work_validate (root1, work)) { auto ec = system.poll (); auto transaction (wallet->wallets.tx_begin ()); @@ -1227,19 +1227,19 @@ TEST (rpc, payment_begin_end) TEST (rpc, payment_end_nonempty) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto node1 (system.nodes[0]); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); auto transaction (node1->store.tx_begin ()); system.wallet (0)->init_free_accounts (transaction); auto wallet_id (node1->wallets.items.begin ()->first); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; request1.put ("action", "payment_end"); request1.put ("wallet", wallet_id.to_string ()); - request1.put ("account", rai::test_genesis_key.pub.to_account ()); + request1.put ("account", nano::test_genesis_key.pub.to_account ()); test_response response1 (request1, rpc, system.io_ctx); system.deadline_set (5s); while (response1.status == 0) @@ -1252,14 +1252,14 @@ TEST (rpc, payment_end_nonempty) TEST (rpc, payment_zero_balance) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto node1 (system.nodes[0]); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); auto transaction (node1->store.tx_begin ()); system.wallet (0)->init_free_accounts (transaction); auto wallet_id (node1->wallets.items.begin ()->first); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; request1.put ("action", "payment_begin"); @@ -1272,20 +1272,20 @@ TEST (rpc, payment_zero_balance) } ASSERT_EQ (200, response1.status); auto account_text (response1.json.get ("account")); - rai::uint256_union account; + nano::uint256_union account; ASSERT_FALSE (account.decode_account (account_text)); - ASSERT_NE (rai::test_genesis_key.pub, account); + ASSERT_NE (nano::test_genesis_key.pub, account); } TEST (rpc, payment_begin_reuse) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto node1 (system.nodes[0]); - rai::keypair wallet_id; + nano::keypair wallet_id; auto wallet (node1->wallets.create (wallet_id.pub)); ASSERT_TRUE (node1->wallets.items.find (wallet_id.pub) != node1->wallets.items.end ()); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; request1.put ("action", "payment_begin"); @@ -1298,7 +1298,7 @@ TEST (rpc, payment_begin_reuse) } ASSERT_EQ (200, response1.status); auto account_text (response1.json.get ("account")); - rai::uint256_union account; + nano::uint256_union account; ASSERT_FALSE (account.decode_account (account_text)); ASSERT_TRUE (wallet->exists (account)); ASSERT_EQ (wallet->free_accounts.end (), wallet->free_accounts.find (account)); @@ -1323,17 +1323,17 @@ TEST (rpc, payment_begin_reuse) } ASSERT_EQ (200, response3.status); auto account2_text (response1.json.get ("account")); - rai::uint256_union account2; + nano::uint256_union account2; ASSERT_FALSE (account2.decode_account (account2_text)); ASSERT_EQ (account, account2); } TEST (rpc, payment_begin_locked) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto node1 (system.nodes[0]); - rai::keypair wallet_id; + nano::keypair wallet_id; auto wallet (node1->wallets.create (wallet_id.pub)); { auto transaction (wallet->wallets.tx_begin (true)); @@ -1341,7 +1341,7 @@ TEST (rpc, payment_begin_locked) ASSERT_TRUE (wallet->store.attempt_password (transaction, "")); } ASSERT_TRUE (node1->wallets.items.find (wallet_id.pub) != node1->wallets.items.end ()); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; request1.put ("action", "payment_begin"); @@ -1358,18 +1358,18 @@ TEST (rpc, payment_begin_locked) TEST (rpc, payment_wait) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto node1 (system.nodes[0]); - rai::keypair key; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::keypair key; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; request1.put ("action", "payment_wait"); request1.put ("account", key.pub.to_account ()); - request1.put ("amount", rai::amount (rai::Mxrb_ratio).to_string_dec ()); + request1.put ("amount", nano::amount (nano::Mxrb_ratio).to_string_dec ()); request1.put ("timeout", "100"); test_response response1 (request1, rpc, system.io_ctx); system.deadline_set (5s); @@ -1380,9 +1380,9 @@ TEST (rpc, payment_wait) ASSERT_EQ (200, response1.status); ASSERT_EQ ("nothing", response1.json.get ("status")); request1.put ("timeout", "100000"); - system.wallet (0)->send_action (rai::test_genesis_key.pub, key.pub, rai::Mxrb_ratio); + system.wallet (0)->send_action (nano::test_genesis_key.pub, key.pub, nano::Mxrb_ratio); system.alarm.add (std::chrono::steady_clock::now () + std::chrono::milliseconds (500), [&]() { - system.wallet (0)->send_action (rai::test_genesis_key.pub, key.pub, rai::Mxrb_ratio); + system.wallet (0)->send_action (nano::test_genesis_key.pub, key.pub, nano::Mxrb_ratio); }); test_response response2 (request1, rpc, system.io_ctx); while (response2.status == 0) @@ -1391,7 +1391,7 @@ TEST (rpc, payment_wait) } ASSERT_EQ (200, response2.status); ASSERT_EQ ("success", response2.json.get ("status")); - request1.put ("amount", rai::amount (rai::Mxrb_ratio * 2).to_string_dec ()); + request1.put ("amount", nano::amount (nano::Mxrb_ratio * 2).to_string_dec ()); test_response response3 (request1, rpc, system.io_ctx); system.deadline_set (5s); while (response3.status == 0) @@ -1404,9 +1404,9 @@ TEST (rpc, payment_wait) TEST (rpc, peers) { - rai::system system (24000, 2); - system.nodes[0]->peers.insert (rai::endpoint (boost::asio::ip::address_v6::from_string ("::ffff:80.80.80.80"), 4000), rai::protocol_version); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 2); + system.nodes[0]->peers.insert (nano::endpoint (boost::asio::ip::address_v6::from_string ("::ffff:80.80.80.80"), 4000), nano::protocol_version); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "peers"); @@ -1423,16 +1423,16 @@ TEST (rpc, peers) TEST (rpc, pending) { - rai::system system (24000, 1); - rai::keypair key1; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto block1 (system.wallet (0)->send_action (rai::test_genesis_key.pub, key1.pub, 100)); + nano::system system (24000, 1); + nano::keypair key1; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto block1 (system.wallet (0)->send_action (nano::test_genesis_key.pub, key1.pub, 100)); system.deadline_set (5s); while (system.nodes[0]->active.active (*block1)) { ASSERT_NO_ERROR (system.poll ()); } - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "pending"); @@ -1447,7 +1447,7 @@ TEST (rpc, pending) ASSERT_EQ (200, response.status); auto & blocks_node (response.json.get_child ("blocks")); ASSERT_EQ (1, blocks_node.size ()); - rai::block_hash hash1 (blocks_node.begin ()->second.get ("")); + nano::block_hash hash1 (blocks_node.begin ()->second.get ("")); ASSERT_EQ (block1->hash (), hash1); request.put ("threshold", "100"); // Threshold test test_response response0 (request, rpc, system.io_ctx); @@ -1459,12 +1459,12 @@ TEST (rpc, pending) ASSERT_EQ (200, response0.status); blocks_node = response0.json.get_child ("blocks"); ASSERT_EQ (1, blocks_node.size ()); - std::unordered_map blocks; + std::unordered_map blocks; for (auto i (blocks_node.begin ()), j (blocks_node.end ()); i != j; ++i) { - rai::block_hash hash; + nano::block_hash hash; hash.decode_hex (i->first); - rai::uint128_union amount; + nano::uint128_union amount; amount.decode_dec (i->second.get ("")); blocks[hash] = amount; boost::optional source (i->second.get_optional ("source")); @@ -1494,23 +1494,23 @@ TEST (rpc, pending) ASSERT_EQ (200, response2.status); blocks_node = response2.json.get_child ("blocks"); ASSERT_EQ (1, blocks_node.size ()); - std::unordered_map amounts; - std::unordered_map sources; + std::unordered_map amounts; + std::unordered_map sources; for (auto i (blocks_node.begin ()), j (blocks_node.end ()); i != j; ++i) { - rai::block_hash hash; + nano::block_hash hash; hash.decode_hex (i->first); amounts[hash].decode_dec (i->second.get ("amount")); sources[hash].decode_account (i->second.get ("source")); ASSERT_EQ (i->second.get ("min_version"), 0); } ASSERT_EQ (amounts[block1->hash ()], 100); - ASSERT_EQ (sources[block1->hash ()], rai::test_genesis_key.pub); + ASSERT_EQ (sources[block1->hash ()], nano::test_genesis_key.pub); } TEST (rpc_config, serialization) { - rai::rpc_config config1; + nano::rpc_config config1; config1.address = boost::asio::ip::address_v6::any (); config1.port = 10; config1.enable_control = true; @@ -1518,7 +1518,7 @@ TEST (rpc_config, serialization) config1.chain_request_limit = 4096; boost::property_tree::ptree tree; config1.serialize_json (tree); - rai::rpc_config config2; + nano::rpc_config config2; ASSERT_NE (config2.address, config1.address); ASSERT_NE (config2.port, config1.port); ASSERT_NE (config2.enable_control, config1.enable_control); @@ -1534,13 +1534,13 @@ TEST (rpc_config, serialization) TEST (rpc, search_pending) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); auto wallet (system.nodes[0]->wallets.items.begin ()->first.to_string ()); - rai::send_block block (system.nodes[0]->latest (rai::test_genesis_key.pub), rai::test_genesis_key.pub, rai::genesis_amount - system.nodes[0]->config.receive_minimum.number (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); + nano::send_block block (system.nodes[0]->latest (nano::test_genesis_key.pub), nano::test_genesis_key.pub, nano::genesis_amount - system.nodes[0]->config.receive_minimum.number (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); auto transaction (system.nodes[0]->store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->ledger.process (transaction, block).code); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->ledger.process (transaction, block).code); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "search_pending"); @@ -1553,7 +1553,7 @@ TEST (rpc, search_pending) } ASSERT_EQ (200, response.status); system.deadline_set (10s); - while (system.nodes[0]->balance (rai::test_genesis_key.pub) != rai::genesis_amount) + while (system.nodes[0]->balance (nano::test_genesis_key.pub) != nano::genesis_amount) { ASSERT_NO_ERROR (system.poll ()); } @@ -1561,13 +1561,13 @@ TEST (rpc, search_pending) TEST (rpc, version) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto node1 (system.nodes[0]); - rai::keypair key; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::keypair key; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; request1.put ("action", "version"); @@ -1584,8 +1584,8 @@ TEST (rpc, version) auto transaction (system.nodes[0]->store.tx_begin ()); ASSERT_EQ (std::to_string (node1->store.version_get (transaction)), response1.json.get ("store_version")); } - ASSERT_EQ (std::to_string (rai::protocol_version), response1.json.get ("protocol_version")); - ASSERT_EQ (boost::str (boost::format ("RaiBlocks %1%.%2%") % RAIBLOCKS_VERSION_MAJOR % RAIBLOCKS_VERSION_MINOR), response1.json.get ("node_vendor")); + ASSERT_EQ (std::to_string (nano::protocol_version), response1.json.get ("protocol_version")); + ASSERT_EQ (boost::str (boost::format ("Nano %1%.%2%") % NANO_VERSION_MAJOR % NANO_VERSION_MINOR), response1.json.get ("node_vendor")); auto headers (response1.resp.base ()); auto allowed_origin (headers.at ("Access-Control-Allow-Origin")); auto allowed_headers (headers.at ("Access-Control-Allow-Headers")); @@ -1595,15 +1595,15 @@ TEST (rpc, version) TEST (rpc, work_generate) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto node1 (system.nodes[0]); - rai::keypair key; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::keypair key; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); - rai::block_hash hash1 (1); + nano::block_hash hash1 (1); boost::property_tree::ptree request1; request1.put ("action", "work_generate"); request1.put ("hash", hash1.to_string ()); @@ -1616,21 +1616,21 @@ TEST (rpc, work_generate) ASSERT_EQ (200, response1.status); auto work1 (response1.json.get ("work")); uint64_t work2; - ASSERT_FALSE (rai::from_string_hex (work1, work2)); - ASSERT_FALSE (rai::work_validate (hash1, work2)); + ASSERT_FALSE (nano::from_string_hex (work1, work2)); + ASSERT_FALSE (nano::work_validate (hash1, work2)); } TEST (rpc, work_cancel) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto & node1 (*system.nodes[0]); - rai::keypair key; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::keypair key; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); - rai::block_hash hash1 (1); + nano::block_hash hash1 (1); boost::property_tree::ptree request1; request1.put ("action", "work_cancel"); request1.put ("hash", hash1.to_string ()); @@ -1654,23 +1654,23 @@ TEST (rpc, work_cancel) TEST (rpc, work_peer_bad) { - rai::system system (24000, 2); - rai::node_init init1; + nano::system system (24000, 2); + nano::node_init init1; auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); - rai::keypair key; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::keypair key; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); node2.config.work_peers.push_back (std::make_pair (boost::asio::ip::address_v6::any ().to_string (), 0)); - rai::block_hash hash1 (1); + nano::block_hash hash1 (1); std::atomic work (0); node2.work_generate (hash1, [&work](uint64_t work_a) { work = work_a; }); system.deadline_set (5s); - while (rai::work_validate (hash1, work)) + while (nano::work_validate (hash1, work)) { ASSERT_NO_ERROR (system.poll ()); } @@ -1678,23 +1678,23 @@ TEST (rpc, work_peer_bad) TEST (rpc, work_peer_one) { - rai::system system (24000, 2); - rai::node_init init1; + nano::system system (24000, 2); + nano::node_init init1; auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); - rai::keypair key; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::keypair key; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); node2.config.work_peers.push_back (std::make_pair (node1.network.endpoint ().address ().to_string (), rpc.config.port)); - rai::keypair key1; + nano::keypair key1; uint64_t work (0); node2.work_generate (key1.pub, [&work](uint64_t work_a) { work = work_a; }); system.deadline_set (5s); - while (rai::work_validate (key1.pub, work)) + while (nano::work_validate (key1.pub, work)) { ASSERT_NO_ERROR (system.poll ()); } @@ -1702,39 +1702,39 @@ TEST (rpc, work_peer_one) TEST (rpc, work_peer_many) { - rai::system system1 (24000, 1); - rai::system system2 (24001, 1); - rai::system system3 (24002, 1); - rai::system system4 (24003, 1); - rai::node_init init1; + nano::system system1 (24000, 1); + nano::system system2 (24001, 1); + nano::system system3 (24002, 1); + nano::system system4 (24003, 1); + nano::node_init init1; auto & node1 (*system1.nodes[0]); auto & node2 (*system2.nodes[0]); auto & node3 (*system3.nodes[0]); auto & node4 (*system4.nodes[0]); - rai::keypair key; - rai::rpc_config config2 (true); + nano::keypair key; + nano::rpc_config config2 (true); config2.port += 0; - rai::rpc rpc2 (system2.io_ctx, node2, config2); + nano::rpc rpc2 (system2.io_ctx, node2, config2); rpc2.start (); - rai::rpc_config config3 (true); + nano::rpc_config config3 (true); config3.port += 1; - rai::rpc rpc3 (system3.io_ctx, node3, config3); + nano::rpc rpc3 (system3.io_ctx, node3, config3); rpc3.start (); - rai::rpc_config config4 (true); + nano::rpc_config config4 (true); config4.port += 2; - rai::rpc rpc4 (system4.io_ctx, node4, config4); + nano::rpc rpc4 (system4.io_ctx, node4, config4); rpc4.start (); node1.config.work_peers.push_back (std::make_pair (node2.network.endpoint ().address ().to_string (), rpc2.config.port)); node1.config.work_peers.push_back (std::make_pair (node3.network.endpoint ().address ().to_string (), rpc3.config.port)); node1.config.work_peers.push_back (std::make_pair (node4.network.endpoint ().address ().to_string (), rpc4.config.port)); for (auto i (0); i < 10; ++i) { - rai::keypair key1; + nano::keypair key1; uint64_t work (0); node1.work_generate (key1.pub, [&work](uint64_t work_a) { work = work_a; }); - while (rai::work_validate (key1.pub, work)) + while (nano::work_validate (key1.pub, work)) { system1.poll (); system2.poll (); @@ -1746,10 +1746,10 @@ TEST (rpc, work_peer_many) TEST (rpc, block_count) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto & node1 (*system.nodes[0]); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; request1.put ("action", "block_count"); @@ -1766,10 +1766,10 @@ TEST (rpc, block_count) TEST (rpc, frontier_count) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto & node1 (*system.nodes[0]); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; request1.put ("action", "frontier_count"); @@ -1785,10 +1785,10 @@ TEST (rpc, frontier_count) TEST (rpc, account_count) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto & node1 (*system.nodes[0]); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; request1.put ("action", "account_count"); @@ -1804,10 +1804,10 @@ TEST (rpc, account_count) TEST (rpc, available_supply) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto & node1 (*system.nodes[0]); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; request1.put ("action", "available_supply"); @@ -1819,9 +1819,9 @@ TEST (rpc, available_supply) } ASSERT_EQ (200, response1.status); ASSERT_EQ ("0", response1.json.get ("available")); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key; - auto block (system.wallet (0)->send_action (rai::test_genesis_key.pub, key.pub, 1)); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key; + auto block (system.wallet (0)->send_action (nano::test_genesis_key.pub, key.pub, 1)); test_response response2 (request1, rpc, system.io_ctx); system.deadline_set (5s); while (response2.status == 0) @@ -1830,7 +1830,7 @@ TEST (rpc, available_supply) } ASSERT_EQ (200, response2.status); ASSERT_EQ ("1", response2.json.get ("available")); - auto block2 (system.wallet (0)->send_action (rai::test_genesis_key.pub, 0, 100)); // Sending to burning 0 account + auto block2 (system.wallet (0)->send_action (nano::test_genesis_key.pub, 0, 100)); // Sending to burning 0 account test_response response3 (request1, rpc, system.io_ctx); system.deadline_set (5s); while (response3.status == 0) @@ -1843,10 +1843,10 @@ TEST (rpc, available_supply) TEST (rpc, mrai_to_raw) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto & node1 (*system.nodes[0]); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; request1.put ("action", "mrai_to_raw"); @@ -1858,19 +1858,19 @@ TEST (rpc, mrai_to_raw) ASSERT_NO_ERROR (system.poll ()); } ASSERT_EQ (200, response1.status); - ASSERT_EQ (rai::Mxrb_ratio.convert_to (), response1.json.get ("amount")); + ASSERT_EQ (nano::Mxrb_ratio.convert_to (), response1.json.get ("amount")); } TEST (rpc, mrai_from_raw) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto & node1 (*system.nodes[0]); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; request1.put ("action", "mrai_from_raw"); - request1.put ("amount", rai::Mxrb_ratio.convert_to ()); + request1.put ("amount", nano::Mxrb_ratio.convert_to ()); test_response response1 (request1, rpc, system.io_ctx); system.deadline_set (5s); while (response1.status == 0) @@ -1883,10 +1883,10 @@ TEST (rpc, mrai_from_raw) TEST (rpc, krai_to_raw) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto & node1 (*system.nodes[0]); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; request1.put ("action", "krai_to_raw"); @@ -1898,19 +1898,19 @@ TEST (rpc, krai_to_raw) ASSERT_NO_ERROR (system.poll ()); } ASSERT_EQ (200, response1.status); - ASSERT_EQ (rai::kxrb_ratio.convert_to (), response1.json.get ("amount")); + ASSERT_EQ (nano::kxrb_ratio.convert_to (), response1.json.get ("amount")); } TEST (rpc, krai_from_raw) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto & node1 (*system.nodes[0]); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; request1.put ("action", "krai_from_raw"); - request1.put ("amount", rai::kxrb_ratio.convert_to ()); + request1.put ("amount", nano::kxrb_ratio.convert_to ()); test_response response1 (request1, rpc, system.io_ctx); system.deadline_set (5s); while (response1.status == 0) @@ -1921,15 +1921,15 @@ TEST (rpc, krai_from_raw) ASSERT_EQ ("1", response1.json.get ("amount")); } -TEST (rpc, rai_to_raw) +TEST (rpc, nano_to_raw) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto & node1 (*system.nodes[0]); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; - request1.put ("action", "rai_to_raw"); + request1.put ("action", "nano_to_raw"); request1.put ("amount", "1"); test_response response1 (request1, rpc, system.io_ctx); system.deadline_set (5s); @@ -1938,19 +1938,19 @@ TEST (rpc, rai_to_raw) ASSERT_NO_ERROR (system.poll ()); } ASSERT_EQ (200, response1.status); - ASSERT_EQ (rai::xrb_ratio.convert_to (), response1.json.get ("amount")); + ASSERT_EQ (nano::xrb_ratio.convert_to (), response1.json.get ("amount")); } -TEST (rpc, rai_from_raw) +TEST (rpc, nano_from_raw) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto & node1 (*system.nodes[0]); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request1; - request1.put ("action", "rai_from_raw"); - request1.put ("amount", rai::xrb_ratio.convert_to ()); + request1.put ("action", "nano_from_raw"); + request1.put ("amount", nano::xrb_ratio.convert_to ()); test_response response1 (request1, rpc, system.io_ctx); system.deadline_set (5s); while (response1.status == 0) @@ -1963,12 +1963,12 @@ TEST (rpc, rai_from_raw) TEST (rpc, account_representative) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; std::string wallet; - request.put ("account", rai::genesis_account.to_account ()); + request.put ("account", nano::genesis_account.to_account ()); request.put ("action", "account_representative"); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); @@ -1978,18 +1978,18 @@ TEST (rpc, account_representative) } ASSERT_EQ (200, response.status); std::string account_text1 (response.json.get ("representative")); - ASSERT_EQ (account_text1, rai::genesis_account.to_account ()); + ASSERT_EQ (account_text1, nano::genesis_account.to_account ()); } TEST (rpc, account_representative_set) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; - rai::keypair rep; - request.put ("account", rai::genesis_account.to_account ()); + nano::keypair rep; + request.put ("account", nano::genesis_account.to_account ()); request.put ("representative", rep.pub.to_account ()); request.put ("wallet", system.nodes[0]->wallets.items.begin ()->first.to_string ()); request.put ("action", "account_representative_set"); @@ -2001,7 +2001,7 @@ TEST (rpc, account_representative_set) } ASSERT_EQ (200, response.status); std::string block_text1 (response.json.get ("block")); - rai::block_hash hash; + nano::block_hash hash; ASSERT_FALSE (hash.decode_hex (block_text1)); ASSERT_FALSE (hash.is_zero ()); auto transaction (system.nodes[0]->store.tx_begin ()); @@ -2011,15 +2011,15 @@ TEST (rpc, account_representative_set) TEST (rpc, bootstrap) { - rai::system system0 (24000, 1); - rai::system system1 (24001, 1); - auto latest (system1.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::send_block send (latest, rai::genesis_account, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system1.nodes[0]->work_generate_blocking (latest)); + nano::system system0 (24000, 1); + nano::system system1 (24001, 1); + auto latest (system1.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::send_block send (latest, nano::genesis_account, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system1.nodes[0]->work_generate_blocking (latest)); { auto transaction (system1.nodes[0]->store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, system1.nodes[0]->ledger.process (transaction, send).code); + ASSERT_EQ (nano::process_result::progress, system1.nodes[0]->ledger.process (transaction, send).code); } - rai::rpc rpc (system0.io_ctx, *system0.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system0.io_ctx, *system0.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "bootstrap"); @@ -2031,7 +2031,7 @@ TEST (rpc, bootstrap) system0.poll (); } system1.deadline_set (10s); - while (system0.nodes[0]->latest (rai::genesis_account) != system1.nodes[0]->latest (rai::genesis_account)) + while (system0.nodes[0]->latest (nano::genesis_account) != system1.nodes[0]->latest (nano::genesis_account)) { ASSERT_NO_ERROR (system0.poll ()); ASSERT_NO_ERROR (system1.poll ()); @@ -2040,10 +2040,10 @@ TEST (rpc, bootstrap) TEST (rpc, account_remove) { - rai::system system0 (24000, 1); + nano::system system0 (24000, 1); auto key1 (system0.wallet (0)->deterministic_insert ()); ASSERT_TRUE (system0.wallet (0)->exists (key1)); - rai::rpc rpc (system0.io_ctx, *system0.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system0.io_ctx, *system0.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "account_remove"); @@ -2059,8 +2059,8 @@ TEST (rpc, account_remove) TEST (rpc, representatives) { - rai::system system0 (24000, 1); - rai::rpc rpc (system0.io_ctx, *system0.nodes[0], rai::rpc_config (true)); + nano::system system0 (24000, 1); + nano::rpc rpc (system0.io_ctx, *system0.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "representatives"); @@ -2071,28 +2071,28 @@ TEST (rpc, representatives) } ASSERT_EQ (200, response.status); auto & representatives_node (response.json.get_child ("representatives")); - std::vector representatives; + std::vector representatives; for (auto i (representatives_node.begin ()), n (representatives_node.end ()); i != n; ++i) { - rai::account account; + nano::account account; ASSERT_FALSE (account.decode_account (i->first)); representatives.push_back (account); } ASSERT_EQ (1, representatives.size ()); - ASSERT_EQ (rai::genesis_account, representatives[0]); + ASSERT_EQ (nano::genesis_account, representatives[0]); } TEST (rpc, wallet_change_seed) { - rai::system system0 (24000, 1); - rai::keypair seed; + nano::system system0 (24000, 1); + nano::keypair seed; { auto transaction (system0.nodes[0]->store.tx_begin ()); - rai::raw_key seed0; + nano::raw_key seed0; system0.wallet (0)->store.seed (seed0, transaction); ASSERT_NE (seed.pub, seed0.data); } - rai::rpc rpc (system0.io_ctx, *system0.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system0.io_ctx, *system0.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "wallet_change_seed"); @@ -2106,7 +2106,7 @@ TEST (rpc, wallet_change_seed) ASSERT_EQ (200, response.status); { auto transaction (system0.nodes[0]->store.tx_begin ()); - rai::raw_key seed0; + nano::raw_key seed0; system0.wallet (0)->store.seed (seed0, transaction); ASSERT_EQ (seed.pub, seed0.data); } @@ -2114,9 +2114,9 @@ TEST (rpc, wallet_change_seed) TEST (rpc, wallet_frontiers) { - rai::system system0 (24000, 1); - system0.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::rpc rpc (system0.io_ctx, *system0.nodes[0], rai::rpc_config (true)); + nano::system system0 (24000, 1); + system0.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::rpc rpc (system0.io_ctx, *system0.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "wallet_frontiers"); @@ -2128,31 +2128,31 @@ TEST (rpc, wallet_frontiers) } ASSERT_EQ (200, response.status); auto & frontiers_node (response.json.get_child ("frontiers")); - std::vector frontiers; + std::vector frontiers; for (auto i (frontiers_node.begin ()), n (frontiers_node.end ()); i != n; ++i) { - frontiers.push_back (rai::block_hash (i->second.get (""))); + frontiers.push_back (nano::block_hash (i->second.get (""))); } ASSERT_EQ (1, frontiers.size ()); - ASSERT_EQ (system0.nodes[0]->latest (rai::genesis_account), frontiers[0]); + ASSERT_EQ (system0.nodes[0]->latest (nano::genesis_account), frontiers[0]); } TEST (rpc, work_validate) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto & node1 (*system.nodes[0]); - rai::keypair key; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::keypair key; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); - rai::block_hash hash (1); + nano::block_hash hash (1); uint64_t work1 (node1.work_generate_blocking (hash)); boost::property_tree::ptree request; request.put ("action", "work_validate"); request.put ("hash", hash.to_string ()); - request.put ("work", rai::to_string_hex (work1)); + request.put ("work", nano::to_string_hex (work1)); test_response response1 (request, rpc, system.io_ctx); system.deadline_set (5s); while (response1.status == 0) @@ -2163,7 +2163,7 @@ TEST (rpc, work_validate) std::string validate_text1 (response1.json.get ("valid")); ASSERT_EQ ("1", validate_text1); uint64_t work2 (0); - request.put ("work", rai::to_string_hex (work2)); + request.put ("work", nano::to_string_hex (work2)); test_response response2 (request, rpc, system.io_ctx); system.deadline_set (5s); while (response2.status == 0) @@ -2177,14 +2177,14 @@ TEST (rpc, work_validate) TEST (rpc, successors) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key; - auto genesis (system.nodes[0]->latest (rai::test_genesis_key.pub)); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key; + auto genesis (system.nodes[0]->latest (nano::test_genesis_key.pub)); ASSERT_FALSE (genesis.is_zero ()); - auto block (system.wallet (0)->send_action (rai::test_genesis_key.pub, key.pub, 1)); + auto block (system.wallet (0)->send_action (nano::test_genesis_key.pub, key.pub, 1)); ASSERT_NE (nullptr, block); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "successors"); @@ -2198,10 +2198,10 @@ TEST (rpc, successors) } ASSERT_EQ (200, response.status); auto & blocks_node (response.json.get_child ("blocks")); - std::vector blocks; + std::vector blocks; for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i) { - blocks.push_back (rai::block_hash (i->second.get (""))); + blocks.push_back (nano::block_hash (i->second.get (""))); } ASSERT_EQ (2, blocks.size ()); ASSERT_EQ (genesis, blocks[0]); @@ -2210,15 +2210,15 @@ TEST (rpc, successors) TEST (rpc, bootstrap_any) { - rai::system system0 (24000, 1); - rai::system system1 (24001, 1); - auto latest (system1.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::send_block send (latest, rai::genesis_account, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system1.nodes[0]->work_generate_blocking (latest)); + nano::system system0 (24000, 1); + nano::system system1 (24001, 1); + auto latest (system1.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::send_block send (latest, nano::genesis_account, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system1.nodes[0]->work_generate_blocking (latest)); { auto transaction (system1.nodes[0]->store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, system1.nodes[0]->ledger.process (transaction, send).code); + ASSERT_EQ (nano::process_result::progress, system1.nodes[0]->ledger.process (transaction, send).code); } - rai::rpc rpc (system0.io_ctx, *system0.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system0.io_ctx, *system0.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "bootstrap_any"); @@ -2233,16 +2233,16 @@ TEST (rpc, bootstrap_any) TEST (rpc, republish) { - rai::system system (24000, 2); - rai::keypair key; - rai::genesis genesis; - auto latest (system.nodes[0]->latest (rai::test_genesis_key.pub)); + nano::system system (24000, 2); + nano::keypair key; + nano::genesis genesis; + auto latest (system.nodes[0]->latest (nano::test_genesis_key.pub)); auto & node1 (*system.nodes[0]); - rai::send_block send (latest, key.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, node1.work_generate_blocking (latest)); + nano::send_block send (latest, key.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, node1.work_generate_blocking (latest)); system.nodes[0]->process (send); - rai::open_block open (send.hash (), key.pub, key.pub, key.prv, key.pub, node1.work_generate_blocking (key.pub)); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (open).code); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::open_block open (send.hash (), key.pub, key.pub, key.prv, key.pub, node1.work_generate_blocking (key.pub)); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "republish"); @@ -2255,15 +2255,15 @@ TEST (rpc, republish) } ASSERT_EQ (200, response.status); system.deadline_set (10s); - while (system.nodes[1]->balance (rai::test_genesis_key.pub) == rai::genesis_amount) + while (system.nodes[1]->balance (nano::test_genesis_key.pub) == nano::genesis_amount) { ASSERT_NO_ERROR (system.poll ()); } auto & blocks_node (response.json.get_child ("blocks")); - std::vector blocks; + std::vector blocks; for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i) { - blocks.push_back (rai::block_hash (i->second.get (""))); + blocks.push_back (nano::block_hash (i->second.get (""))); } ASSERT_EQ (1, blocks.size ()); ASSERT_EQ (send.hash (), blocks[0]); @@ -2282,7 +2282,7 @@ TEST (rpc, republish) blocks.clear (); for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i) { - blocks.push_back (rai::block_hash (i->second.get (""))); + blocks.push_back (nano::block_hash (i->second.get (""))); } ASSERT_EQ (1, blocks.size ()); ASSERT_EQ (genesis.hash (), blocks[0]); @@ -2299,7 +2299,7 @@ TEST (rpc, republish) blocks.clear (); for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i) { - blocks.push_back (rai::block_hash (i->second.get (""))); + blocks.push_back (nano::block_hash (i->second.get (""))); } ASSERT_EQ (3, blocks.size ()); ASSERT_EQ (genesis.hash (), blocks[0]); @@ -2309,16 +2309,16 @@ TEST (rpc, republish) TEST (rpc, deterministic_key) { - rai::system system0 (24000, 1); - rai::raw_key seed; + nano::system system0 (24000, 1); + nano::raw_key seed; { auto transaction (system0.nodes[0]->store.tx_begin ()); system0.wallet (0)->store.seed (seed, transaction); } - rai::account account0 (system0.wallet (0)->deterministic_insert ()); - rai::account account1 (system0.wallet (0)->deterministic_insert ()); - rai::account account2 (system0.wallet (0)->deterministic_insert ()); - rai::rpc rpc (system0.io_ctx, *system0.nodes[0], rai::rpc_config (true)); + nano::account account0 (system0.wallet (0)->deterministic_insert ()); + nano::account account1 (system0.wallet (0)->deterministic_insert ()); + nano::account account2 (system0.wallet (0)->deterministic_insert ()); + nano::rpc rpc (system0.io_ctx, *system0.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "deterministic_key"); @@ -2346,14 +2346,14 @@ TEST (rpc, deterministic_key) TEST (rpc, accounts_balances) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "accounts_balances"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", rai::test_genesis_key.pub.to_account ()); + entry.put ("", nano::test_genesis_key.pub.to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); test_response response (request, rpc, system.io_ctx); @@ -2366,7 +2366,7 @@ TEST (rpc, accounts_balances) for (auto & balances : response.json.get_child ("balances")) { std::string account_text (balances.first); - ASSERT_EQ (rai::test_genesis_key.pub.to_account (), account_text); + ASSERT_EQ (nano::test_genesis_key.pub.to_account (), account_text); std::string balance_text (balances.second.get ("balance")); ASSERT_EQ ("340282366920938463463374607431768211455", balance_text); std::string pending_text (balances.second.get ("pending")); @@ -2376,15 +2376,15 @@ TEST (rpc, accounts_balances) TEST (rpc, accounts_frontiers) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "accounts_frontiers"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", rai::test_genesis_key.pub.to_account ()); + entry.put ("", nano::test_genesis_key.pub.to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); test_response response (request, rpc, system.io_ctx); @@ -2397,25 +2397,25 @@ TEST (rpc, accounts_frontiers) for (auto & frontiers : response.json.get_child ("frontiers")) { std::string account_text (frontiers.first); - ASSERT_EQ (rai::test_genesis_key.pub.to_account (), account_text); + ASSERT_EQ (nano::test_genesis_key.pub.to_account (), account_text); std::string frontier_text (frontiers.second.get ("")); - ASSERT_EQ (system.nodes[0]->latest (rai::genesis_account), frontier_text); + ASSERT_EQ (system.nodes[0]->latest (nano::genesis_account), frontier_text); } } TEST (rpc, accounts_pending) { - rai::system system (24000, 1); - rai::keypair key1; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto block1 (system.wallet (0)->send_action (rai::test_genesis_key.pub, key1.pub, 100)); + nano::system system (24000, 1); + nano::keypair key1; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto block1 (system.wallet (0)->send_action (nano::test_genesis_key.pub, key1.pub, 100)); auto iterations (0); system.deadline_set (5s); while (system.nodes[0]->active.active (*block1)) { ASSERT_NO_ERROR (system.poll ()); } - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "accounts_pending"); @@ -2436,7 +2436,7 @@ TEST (rpc, accounts_pending) { std::string account_text (blocks.first); ASSERT_EQ (key1.pub.to_account (), account_text); - rai::block_hash hash1 (blocks.second.begin ()->second.get ("")); + nano::block_hash hash1 (blocks.second.begin ()->second.get ("")); ASSERT_EQ (block1->hash (), hash1); } request.put ("threshold", "100"); // Threshold test @@ -2447,16 +2447,16 @@ TEST (rpc, accounts_pending) ASSERT_NO_ERROR (system.poll ()); } ASSERT_EQ (200, response1.status); - std::unordered_map blocks; + std::unordered_map blocks; for (auto & pending : response1.json.get_child ("blocks")) { std::string account_text (pending.first); ASSERT_EQ (key1.pub.to_account (), account_text); for (auto i (pending.second.begin ()), j (pending.second.end ()); i != j; ++i) { - rai::block_hash hash; + nano::block_hash hash; hash.decode_hex (i->first); - rai::uint128_union amount; + nano::uint128_union amount; amount.decode_dec (i->second.get ("")); blocks[hash] = amount; boost::optional source (i->second.get_optional ("source")); @@ -2472,34 +2472,34 @@ TEST (rpc, accounts_pending) ASSERT_NO_ERROR (system.poll ()); } ASSERT_EQ (200, response2.status); - std::unordered_map amounts; - std::unordered_map sources; + std::unordered_map amounts; + std::unordered_map sources; for (auto & pending : response2.json.get_child ("blocks")) { std::string account_text (pending.first); ASSERT_EQ (key1.pub.to_account (), account_text); for (auto i (pending.second.begin ()), j (pending.second.end ()); i != j; ++i) { - rai::block_hash hash; + nano::block_hash hash; hash.decode_hex (i->first); amounts[hash].decode_dec (i->second.get ("amount")); sources[hash].decode_account (i->second.get ("source")); } } ASSERT_EQ (amounts[block1->hash ()], 100); - ASSERT_EQ (sources[block1->hash ()], rai::test_genesis_key.pub); + ASSERT_EQ (sources[block1->hash ()], nano::test_genesis_key.pub); } TEST (rpc, blocks) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "blocks"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", system.nodes[0]->latest (rai::genesis_account).to_string ()); + entry.put ("", system.nodes[0]->latest (nano::genesis_account).to_string ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("hashes", peers_l); test_response response (request, rpc, system.io_ctx); @@ -2512,7 +2512,7 @@ TEST (rpc, blocks) for (auto & blocks : response.json.get_child ("blocks")) { std::string hash_text (blocks.first); - ASSERT_EQ (system.nodes[0]->latest (rai::genesis_account).to_string (), hash_text); + ASSERT_EQ (system.nodes[0]->latest (nano::genesis_account).to_string (), hash_text); std::string blocks_text (blocks.second.get ("")); ASSERT_FALSE (blocks_text.empty ()); } @@ -2520,18 +2520,18 @@ TEST (rpc, blocks) TEST (rpc, wallet_info) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key; + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key; system.wallet (0)->insert_adhoc (key.prv); - auto send (system.wallet (0)->send_action (rai::test_genesis_key.pub, key.pub, 1)); - rai::account account (system.wallet (0)->deterministic_insert ()); + auto send (system.wallet (0)->send_action (nano::test_genesis_key.pub, key.pub, 1)); + nano::account account (system.wallet (0)->deterministic_insert ()); { auto transaction (system.nodes[0]->store.tx_begin (true)); system.wallet (0)->store.erase (transaction, account); } account = system.wallet (0)->deterministic_insert (); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "wallet_info"); @@ -2559,9 +2559,9 @@ TEST (rpc, wallet_info) TEST (rpc, wallet_balances) { - rai::system system0 (24000, 1); - system0.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::rpc rpc (system0.io_ctx, *system0.nodes[0], rai::rpc_config (true)); + nano::system system0 (24000, 1); + system0.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::rpc rpc (system0.io_ctx, *system0.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "wallet_balances"); @@ -2575,15 +2575,15 @@ TEST (rpc, wallet_balances) for (auto & balances : response.json.get_child ("balances")) { std::string account_text (balances.first); - ASSERT_EQ (rai::test_genesis_key.pub.to_account (), account_text); + ASSERT_EQ (nano::test_genesis_key.pub.to_account (), account_text); std::string balance_text (balances.second.get ("balance")); ASSERT_EQ ("340282366920938463463374607431768211455", balance_text); std::string pending_text (balances.second.get ("pending")); ASSERT_EQ ("0", pending_text); } - rai::keypair key; + nano::keypair key; system0.wallet (0)->insert_adhoc (key.prv); - auto send (system0.wallet (0)->send_action (rai::test_genesis_key.pub, key.pub, 1)); + auto send (system0.wallet (0)->send_action (nano::test_genesis_key.pub, key.pub, 1)); request.put ("threshold", "2"); test_response response1 (request, rpc, system0.io_ctx); while (response1.status == 0) @@ -2594,7 +2594,7 @@ TEST (rpc, wallet_balances) for (auto & balances : response1.json.get_child ("balances")) { std::string account_text (balances.first); - ASSERT_EQ (rai::test_genesis_key.pub.to_account (), account_text); + ASSERT_EQ (nano::test_genesis_key.pub.to_account (), account_text); std::string balance_text (balances.second.get ("balance")); ASSERT_EQ ("340282366920938463463374607431768211454", balance_text); std::string pending_text (balances.second.get ("pending")); @@ -2604,17 +2604,17 @@ TEST (rpc, wallet_balances) TEST (rpc, pending_exists) { - rai::system system (24000, 1); - rai::keypair key1; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto hash0 (system.nodes[0]->latest (rai::genesis_account)); - auto block1 (system.wallet (0)->send_action (rai::test_genesis_key.pub, key1.pub, 100)); + nano::system system (24000, 1); + nano::keypair key1; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto hash0 (system.nodes[0]->latest (nano::genesis_account)); + auto block1 (system.wallet (0)->send_action (nano::test_genesis_key.pub, key1.pub, 100)); system.deadline_set (5s); while (system.nodes[0]->active.active (*block1)) { ASSERT_NO_ERROR (system.poll ()); } - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "pending_exists"); @@ -2642,11 +2642,11 @@ TEST (rpc, pending_exists) TEST (rpc, wallet_pending) { - rai::system system0 (24000, 1); - rai::keypair key1; - system0.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system0 (24000, 1); + nano::keypair key1; + system0.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system0.wallet (0)->insert_adhoc (key1.prv); - auto block1 (system0.wallet (0)->send_action (rai::test_genesis_key.pub, key1.pub, 100)); + auto block1 (system0.wallet (0)->send_action (nano::test_genesis_key.pub, key1.pub, 100)); auto iterations (0); while (system0.nodes[0]->active.active (*block1)) { @@ -2654,7 +2654,7 @@ TEST (rpc, wallet_pending) ++iterations; ASSERT_LT (iterations, 200); } - rai::rpc rpc (system0.io_ctx, *system0.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system0.io_ctx, *system0.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "wallet_pending"); @@ -2671,7 +2671,7 @@ TEST (rpc, wallet_pending) { std::string account_text (pending.first); ASSERT_EQ (key1.pub.to_account (), account_text); - rai::block_hash hash1 (pending.second.begin ()->second.get ("")); + nano::block_hash hash1 (pending.second.begin ()->second.get ("")); ASSERT_EQ (block1->hash (), hash1); } request.put ("threshold", "100"); // Threshold test @@ -2681,7 +2681,7 @@ TEST (rpc, wallet_pending) system0.poll (); } ASSERT_EQ (200, response0.status); - std::unordered_map blocks; + std::unordered_map blocks; ASSERT_EQ (1, response0.json.get_child ("blocks").size ()); for (auto & pending : response0.json.get_child ("blocks")) { @@ -2689,9 +2689,9 @@ TEST (rpc, wallet_pending) ASSERT_EQ (key1.pub.to_account (), account_text); for (auto i (pending.second.begin ()), j (pending.second.end ()); i != j; ++i) { - rai::block_hash hash; + nano::block_hash hash; hash.decode_hex (i->first); - rai::uint128_union amount; + nano::uint128_union amount; amount.decode_dec (i->second.get ("")); blocks[hash] = amount; boost::optional source (i->second.get_optional ("source")); @@ -2719,8 +2719,8 @@ TEST (rpc, wallet_pending) system0.poll (); } ASSERT_EQ (200, response2.status); - std::unordered_map amounts; - std::unordered_map sources; + std::unordered_map amounts; + std::unordered_map sources; ASSERT_EQ (1, response0.json.get_child ("blocks").size ()); for (auto & pending : response2.json.get_child ("blocks")) { @@ -2728,7 +2728,7 @@ TEST (rpc, wallet_pending) ASSERT_EQ (key1.pub.to_account (), account_text); for (auto i (pending.second.begin ()), j (pending.second.end ()); i != j; ++i) { - rai::block_hash hash; + nano::block_hash hash; hash.decode_hex (i->first); amounts[hash].decode_dec (i->second.get ("amount")); sources[hash].decode_account (i->second.get ("source")); @@ -2736,13 +2736,13 @@ TEST (rpc, wallet_pending) } } ASSERT_EQ (amounts[block1->hash ()], 100); - ASSERT_EQ (sources[block1->hash ()], rai::test_genesis_key.pub); + ASSERT_EQ (sources[block1->hash ()], nano::test_genesis_key.pub); } TEST (rpc, receive_minimum) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "receive_minimum"); @@ -2759,8 +2759,8 @@ TEST (rpc, receive_minimum) TEST (rpc, receive_minimum_set) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "receive_minimum_set"); @@ -2780,15 +2780,15 @@ TEST (rpc, receive_minimum_set) TEST (rpc, work_get) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - system.wallet (0)->work_cache_blocking (rai::test_genesis_key.pub, system.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + system.wallet (0)->work_cache_blocking (nano::test_genesis_key.pub, system.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "work_get"); request.put ("wallet", system.nodes[0]->wallets.items.begin ()->first.to_string ()); - request.put ("account", rai::test_genesis_key.pub.to_account ()); + request.put ("account", nano::test_genesis_key.pub.to_account ()); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); while (response.status == 0) @@ -2799,16 +2799,16 @@ TEST (rpc, work_get) std::string work_text (response.json.get ("work")); uint64_t work (1); auto transaction (system.nodes[0]->store.tx_begin ()); - system.nodes[0]->wallets.items.begin ()->second->store.work_get (transaction, rai::genesis_account, work); - ASSERT_EQ (rai::to_string_hex (work), work_text); + system.nodes[0]->wallets.items.begin ()->second->store.work_get (transaction, nano::genesis_account, work); + ASSERT_EQ (nano::to_string_hex (work), work_text); } TEST (rpc, wallet_work_get) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - system.wallet (0)->work_cache_blocking (rai::test_genesis_key.pub, system.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + system.wallet (0)->work_cache_blocking (nano::test_genesis_key.pub, system.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "wallet_work_get"); @@ -2824,26 +2824,26 @@ TEST (rpc, wallet_work_get) for (auto & works : response.json.get_child ("works")) { std::string account_text (works.first); - ASSERT_EQ (rai::test_genesis_key.pub.to_account (), account_text); + ASSERT_EQ (nano::test_genesis_key.pub.to_account (), account_text); std::string work_text (works.second.get ("")); uint64_t work (1); - system.nodes[0]->wallets.items.begin ()->second->store.work_get (transaction, rai::genesis_account, work); - ASSERT_EQ (rai::to_string_hex (work), work_text); + system.nodes[0]->wallets.items.begin ()->second->store.work_get (transaction, nano::genesis_account, work); + ASSERT_EQ (nano::to_string_hex (work), work_text); } } TEST (rpc, work_set) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); uint64_t work0 (100); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "work_set"); request.put ("wallet", system.nodes[0]->wallets.items.begin ()->first.to_string ()); - request.put ("account", rai::test_genesis_key.pub.to_account ()); - request.put ("work", rai::to_string_hex (work0)); + request.put ("account", nano::test_genesis_key.pub.to_account ()); + request.put ("work", nano::to_string_hex (work0)); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); while (response.status == 0) @@ -2855,18 +2855,18 @@ TEST (rpc, work_set) ASSERT_TRUE (success.empty ()); uint64_t work1 (1); auto transaction (system.nodes[0]->store.tx_begin ()); - system.nodes[0]->wallets.items.begin ()->second->store.work_get (transaction, rai::genesis_account, work1); + system.nodes[0]->wallets.items.begin ()->second->store.work_get (transaction, nano::genesis_account, work1); ASSERT_EQ (work1, work0); } TEST (rpc, search_pending_all) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::send_block block (system.nodes[0]->latest (rai::test_genesis_key.pub), rai::test_genesis_key.pub, rai::genesis_amount - system.nodes[0]->config.receive_minimum.number (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::send_block block (system.nodes[0]->latest (nano::test_genesis_key.pub), nano::test_genesis_key.pub, nano::genesis_amount - system.nodes[0]->config.receive_minimum.number (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); auto transaction (system.nodes[0]->store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->ledger.process (transaction, block).code); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->ledger.process (transaction, block).code); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "search_pending_all"); @@ -2878,7 +2878,7 @@ TEST (rpc, search_pending_all) } ASSERT_EQ (200, response.status); system.deadline_set (10s); - while (system.nodes[0]->balance (rai::test_genesis_key.pub) != rai::genesis_amount) + while (system.nodes[0]->balance (nano::test_genesis_key.pub) != nano::genesis_amount) { ASSERT_NO_ERROR (system.poll ()); } @@ -2886,24 +2886,24 @@ TEST (rpc, search_pending_all) TEST (rpc, wallet_republish) { - rai::system system (24000, 1); - rai::genesis genesis; - rai::keypair key; - while (key.pub < rai::test_genesis_key.pub) + nano::system system (24000, 1); + nano::genesis genesis; + nano::keypair key; + while (key.pub < nano::test_genesis_key.pub) { - rai::keypair key1; + nano::keypair key1; key.pub = key1.pub; key.prv.data = key1.prv.data; } - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); auto & node1 (*system.nodes[0]); - auto latest (system.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::send_block send (latest, key.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, node1.work_generate_blocking (latest)); + auto latest (system.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, node1.work_generate_blocking (latest)); system.nodes[0]->process (send); - rai::open_block open (send.hash (), key.pub, key.pub, key.prv, key.pub, node1.work_generate_blocking (key.pub)); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (open).code); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::open_block open (send.hash (), key.pub, key.pub, key.prv, key.pub, node1.work_generate_blocking (key.pub)); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "wallet_republish"); @@ -2917,10 +2917,10 @@ TEST (rpc, wallet_republish) } ASSERT_EQ (200, response.status); auto & blocks_node (response.json.get_child ("blocks")); - std::vector blocks; + std::vector blocks; for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i) { - blocks.push_back (rai::block_hash (i->second.get (""))); + blocks.push_back (nano::block_hash (i->second.get (""))); } ASSERT_EQ (2, blocks.size ()); ASSERT_EQ (send.hash (), blocks[0]); @@ -2929,21 +2929,21 @@ TEST (rpc, wallet_republish) TEST (rpc, delegators) { - rai::system system (24000, 1); - rai::keypair key; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + nano::keypair key; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); auto & node1 (*system.nodes[0]); - auto latest (system.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::send_block send (latest, key.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, node1.work_generate_blocking (latest)); + auto latest (system.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, node1.work_generate_blocking (latest)); system.nodes[0]->process (send); - rai::open_block open (send.hash (), rai::test_genesis_key.pub, key.pub, key.prv, key.pub, node1.work_generate_blocking (key.pub)); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (open).code); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::open_block open (send.hash (), nano::test_genesis_key.pub, key.pub, key.prv, key.pub, node1.work_generate_blocking (key.pub)); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "delegators"); - request.put ("account", rai::test_genesis_key.pub.to_account ()); + request.put ("account", nano::test_genesis_key.pub.to_account ()); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); while (response.status == 0) @@ -2958,27 +2958,27 @@ TEST (rpc, delegators) delegators.put ((i->first), (i->second.get (""))); } ASSERT_EQ (2, delegators.size ()); - ASSERT_EQ ("100", delegators.get (rai::test_genesis_key.pub.to_account ())); + ASSERT_EQ ("100", delegators.get (nano::test_genesis_key.pub.to_account ())); ASSERT_EQ ("340282366920938463463374607431768211355", delegators.get (key.pub.to_account ())); } TEST (rpc, delegators_count) { - rai::system system (24000, 1); - rai::keypair key; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + nano::keypair key; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); auto & node1 (*system.nodes[0]); - auto latest (system.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::send_block send (latest, key.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, node1.work_generate_blocking (latest)); + auto latest (system.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, node1.work_generate_blocking (latest)); system.nodes[0]->process (send); - rai::open_block open (send.hash (), rai::test_genesis_key.pub, key.pub, key.prv, key.pub, node1.work_generate_blocking (key.pub)); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (open).code); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::open_block open (send.hash (), nano::test_genesis_key.pub, key.pub, key.prv, key.pub, node1.work_generate_blocking (key.pub)); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "delegators_count"); - request.put ("account", rai::test_genesis_key.pub.to_account ()); + request.put ("account", nano::test_genesis_key.pub.to_account ()); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); while (response.status == 0) @@ -2992,22 +2992,22 @@ TEST (rpc, delegators_count) TEST (rpc, account_info) { - rai::system system (24000, 1); - rai::keypair key; - rai::genesis genesis; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + nano::keypair key; + nano::genesis genesis; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); auto & node1 (*system.nodes[0]); - auto latest (system.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::send_block send (latest, key.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, node1.work_generate_blocking (latest)); + auto latest (system.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, node1.work_generate_blocking (latest)); system.nodes[0]->process (send); - auto time (rai::seconds_since_epoch ()); + auto time (nano::seconds_since_epoch ()); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "account_info"); - request.put ("account", rai::test_genesis_key.pub.to_account ()); + request.put ("account", nano::test_genesis_key.pub.to_account ()); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); while (response.status == 0) @@ -3049,19 +3049,19 @@ TEST (rpc, account_info) std::string pending2 (response2.json.get ("pending")); ASSERT_EQ ("0", pending2); std::string representative2 (response2.json.get ("representative")); - ASSERT_EQ (rai::test_genesis_key.pub.to_account (), representative2); + ASSERT_EQ (nano::test_genesis_key.pub.to_account (), representative2); } TEST (rpc, blocks_info) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "blocks_info"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", system.nodes[0]->latest (rai::genesis_account).to_string ()); + entry.put ("", system.nodes[0]->latest (nano::genesis_account).to_string ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("hashes", peers_l); test_response response (request, rpc, system.io_ctx); @@ -3074,11 +3074,11 @@ TEST (rpc, blocks_info) for (auto & blocks : response.json.get_child ("blocks")) { std::string hash_text (blocks.first); - ASSERT_EQ (system.nodes[0]->latest (rai::genesis_account).to_string (), hash_text); + ASSERT_EQ (system.nodes[0]->latest (nano::genesis_account).to_string (), hash_text); std::string account_text (blocks.second.get ("block_account")); - ASSERT_EQ (rai::test_genesis_key.pub.to_account (), account_text); + ASSERT_EQ (nano::test_genesis_key.pub.to_account (), account_text); std::string amount_text (blocks.second.get ("amount")); - ASSERT_EQ (rai::genesis_amount.convert_to (), amount_text); + ASSERT_EQ (nano::genesis_amount.convert_to (), amount_text); std::string blocks_text (blocks.second.get ("contents")); ASSERT_FALSE (blocks_text.empty ()); boost::optional pending (blocks.second.get_optional ("pending")); @@ -3106,17 +3106,17 @@ TEST (rpc, blocks_info) std::string pending (blocks.second.get ("pending")); ASSERT_EQ ("0", pending); std::string balance_text (blocks.second.get ("balance")); - ASSERT_EQ (rai::genesis_amount.convert_to (), balance_text); + ASSERT_EQ (nano::genesis_amount.convert_to (), balance_text); } } TEST (rpc, work_peers_all) { - rai::system system (24000, 1); - rai::node_init init1; + nano::system system (24000, 1); + nano::node_init init1; auto & node1 (*system.nodes[0]); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "work_peer_add"); @@ -3172,13 +3172,13 @@ TEST (rpc, work_peers_all) TEST (rpc, block_count_type) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto send (system.wallet (0)->send_action (rai::test_genesis_key.pub, rai::test_genesis_key.pub, system.nodes[0]->config.receive_minimum.number ())); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto send (system.wallet (0)->send_action (nano::test_genesis_key.pub, nano::test_genesis_key.pub, system.nodes[0]->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); - auto receive (system.wallet (0)->receive_action (*send, rai::test_genesis_key.pub, system.nodes[0]->config.receive_minimum.number ())); + auto receive (system.wallet (0)->receive_action (*send, nano::test_genesis_key.pub, system.nodes[0]->config.receive_minimum.number ())); ASSERT_NE (nullptr, receive); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "block_count_type"); @@ -3203,19 +3203,19 @@ TEST (rpc, block_count_type) TEST (rpc, ledger) { - rai::system system (24000, 1); - rai::keypair key; - rai::genesis genesis; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + nano::keypair key; + nano::genesis genesis; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); auto & node1 (*system.nodes[0]); - auto latest (system.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::send_block send (latest, key.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, node1.work_generate_blocking (latest)); + auto latest (system.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, node1.work_generate_blocking (latest)); system.nodes[0]->process (send); - rai::open_block open (send.hash (), rai::test_genesis_key.pub, key.pub, key.prv, key.pub, node1.work_generate_blocking (key.pub)); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (open).code); - auto time (rai::seconds_since_epoch ()); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::open_block open (send.hash (), nano::test_genesis_key.pub, key.pub, key.prv, key.pub, node1.work_generate_blocking (key.pub)); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code); + auto time (nano::seconds_since_epoch ()); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "ledger"); @@ -3270,14 +3270,14 @@ TEST (rpc, ledger) ASSERT_EQ ("0", pending.get ()); boost::optional representative (accounts.second.get_optional ("representative")); ASSERT_TRUE (representative.is_initialized ()); - ASSERT_EQ (rai::test_genesis_key.pub.to_account (), representative.get ()); + ASSERT_EQ (nano::test_genesis_key.pub.to_account (), representative.get ()); } } TEST (rpc, accounts_create) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "accounts_create"); @@ -3294,7 +3294,7 @@ TEST (rpc, accounts_create) for (auto i (accounts.begin ()), n (accounts.end ()); i != n; ++i) { std::string account_text (i->second.get ("")); - rai::uint256_union account; + nano::uint256_union account; ASSERT_FALSE (account.decode_account (account_text)); ASSERT_TRUE (system.wallet (0)->exists (account)); } @@ -3303,28 +3303,28 @@ TEST (rpc, accounts_create) TEST (rpc, block_create) { - rai::system system (24000, 1); - rai::keypair key; - rai::genesis genesis; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + nano::keypair key; + nano::genesis genesis; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); auto & node1 (*system.nodes[0]); - auto latest (system.nodes[0]->latest (rai::test_genesis_key.pub)); + auto latest (system.nodes[0]->latest (nano::test_genesis_key.pub)); auto send_work = node1.work_generate_blocking (latest); - rai::send_block send (latest, key.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, send_work); + nano::send_block send (latest, key.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, send_work); auto open_work = node1.work_generate_blocking (key.pub); - rai::open_block open (send.hash (), rai::test_genesis_key.pub, key.pub, key.prv, key.pub, open_work); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::open_block open (send.hash (), nano::test_genesis_key.pub, key.pub, key.prv, key.pub, open_work); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "block_create"); request.put ("type", "send"); request.put ("wallet", system.nodes[0]->wallets.items.begin ()->first.to_string ()); - request.put ("account", rai::test_genesis_key.pub.to_account ()); + request.put ("account", nano::test_genesis_key.pub.to_account ()); request.put ("previous", latest.to_string ()); request.put ("amount", "340282366920938463463374607431768211355"); request.put ("destination", key.pub.to_account ()); - request.put ("work", rai::to_string_hex (send_work)); + request.put ("work", nano::to_string_hex (send_work)); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); while (response.status == 0) @@ -3338,7 +3338,7 @@ TEST (rpc, block_create) boost::property_tree::ptree block_l; std::stringstream block_stream (send_text); boost::property_tree::read_json (block_stream, block_l); - auto send_block (rai::deserialize_block_json (block_l)); + auto send_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (send.hash (), send_block->hash ()); system.nodes[0]->process (send); boost::property_tree::ptree request1; @@ -3347,9 +3347,9 @@ TEST (rpc, block_create) std::string key_text; key.prv.data.encode_hex (key_text); request1.put ("key", key_text); - request1.put ("representative", rai::test_genesis_key.pub.to_account ()); + request1.put ("representative", nano::test_genesis_key.pub.to_account ()); request1.put ("source", send.hash ().to_string ()); - request1.put ("work", rai::to_string_hex (open_work)); + request1.put ("work", nano::to_string_hex (open_work)); test_response response1 (request1, rpc, system.io_ctx); system.deadline_set (5s); while (response1.status == 0) @@ -3362,9 +3362,9 @@ TEST (rpc, block_create) auto open_text (response1.json.get ("block")); std::stringstream block_stream1 (open_text); boost::property_tree::read_json (block_stream1, block_l); - auto open_block (rai::deserialize_block_json (block_l)); + auto open_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (open.hash (), open_block->hash ()); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (open).code); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code); request1.put ("representative", key.pub.to_account ()); test_response response2 (request1, rpc, system.io_ctx); system.deadline_set (5s); @@ -3376,9 +3376,9 @@ TEST (rpc, block_create) std::string open2_hash (response2.json.get ("hash")); ASSERT_NE (open.hash ().to_string (), open2_hash); // different blocks with wrong representative auto change_work = node1.work_generate_blocking (open.hash ()); - rai::change_block change (open.hash (), key.pub, key.prv, key.pub, change_work); + nano::change_block change (open.hash (), key.pub, key.prv, key.pub, change_work); request1.put ("type", "change"); - request1.put ("work", rai::to_string_hex (change_work)); + request1.put ("work", nano::to_string_hex (change_work)); test_response response4 (request1, rpc, system.io_ctx); system.deadline_set (5s); while (response4.status == 0) @@ -3391,11 +3391,11 @@ TEST (rpc, block_create) auto change_text (response4.json.get ("block")); std::stringstream block_stream4 (change_text); boost::property_tree::read_json (block_stream4, block_l); - auto change_block (rai::deserialize_block_json (block_l)); + auto change_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (change.hash (), change_block->hash ()); - ASSERT_EQ (rai::process_result::progress, node1.process (change).code); - rai::send_block send2 (send.hash (), key.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, node1.work_generate_blocking (send.hash ())); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (send2).code); + ASSERT_EQ (nano::process_result::progress, node1.process (change).code); + nano::send_block send2 (send.hash (), key.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, node1.work_generate_blocking (send.hash ())); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (send2).code); boost::property_tree::ptree request2; request2.put ("action", "block_create"); request2.put ("type", "receive"); @@ -3403,7 +3403,7 @@ TEST (rpc, block_create) request2.put ("account", key.pub.to_account ()); request2.put ("source", send2.hash ().to_string ()); request2.put ("previous", change.hash ().to_string ()); - request2.put ("work", rai::to_string_hex (node1.work_generate_blocking (change.hash ()))); + request2.put ("work", nano::to_string_hex (node1.work_generate_blocking (change.hash ()))); test_response response5 (request2, rpc, system.io_ctx); system.deadline_set (5s); while (response5.status == 0) @@ -3415,7 +3415,7 @@ TEST (rpc, block_create) auto receive_text (response5.json.get ("block")); std::stringstream block_stream5 (change_text); boost::property_tree::read_json (block_stream5, block_l); - auto receive_block (rai::deserialize_block_json (block_l)); + auto receive_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (receive_hash, receive_block->hash ().to_string ()); system.nodes[0]->process_active (std::move (receive_block)); latest = system.nodes[0]->latest (key.pub); @@ -3424,21 +3424,21 @@ TEST (rpc, block_create) TEST (rpc, block_create_state) { - rai::system system (24000, 1); - rai::keypair key; - rai::genesis genesis; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + nano::keypair key; + nano::genesis genesis; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); boost::property_tree::ptree request; request.put ("action", "block_create"); request.put ("type", "state"); request.put ("wallet", system.nodes[0]->wallets.items.begin ()->first.to_string ()); - request.put ("account", rai::test_genesis_key.pub.to_account ()); + request.put ("account", nano::test_genesis_key.pub.to_account ()); request.put ("previous", genesis.hash ().to_string ()); - request.put ("representative", rai::test_genesis_key.pub.to_account ()); - request.put ("balance", (rai::genesis_amount - rai::Gxrb_ratio).convert_to ()); + request.put ("representative", nano::test_genesis_key.pub.to_account ()); + request.put ("balance", (nano::genesis_amount - nano::Gxrb_ratio).convert_to ()); request.put ("link", key.pub.to_account ()); - request.put ("work", rai::to_string_hex (system.nodes[0]->work_generate_blocking (genesis.hash ()))); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + request.put ("work", nano::to_string_hex (system.nodes[0]->work_generate_blocking (genesis.hash ()))); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); @@ -3452,21 +3452,21 @@ TEST (rpc, block_create_state) std::stringstream block_stream (state_text); boost::property_tree::ptree block_l; boost::property_tree::read_json (block_stream, block_l); - auto state_block (rai::deserialize_block_json (block_l)); + auto state_block (nano::deserialize_block_json (block_l)); ASSERT_NE (nullptr, state_block); - ASSERT_EQ (rai::block_type::state, state_block->type ()); + ASSERT_EQ (nano::block_type::state, state_block->type ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ()); auto process_result (system.nodes[0]->process (*state_block)); - ASSERT_EQ (rai::process_result::progress, process_result.code); + ASSERT_EQ (nano::process_result::progress, process_result.code); } TEST (rpc, block_create_state_open) { - rai::system system (24000, 1); - rai::keypair key; - rai::genesis genesis; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto send_block (system.wallet (0)->send_action (rai::test_genesis_key.pub, key.pub, rai::Gxrb_ratio)); + nano::system system (24000, 1); + nano::keypair key; + nano::genesis genesis; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto send_block (system.wallet (0)->send_action (nano::test_genesis_key.pub, key.pub, nano::Gxrb_ratio)); ASSERT_NE (nullptr, send_block); boost::property_tree::ptree request; request.put ("action", "block_create"); @@ -3474,11 +3474,11 @@ TEST (rpc, block_create_state_open) request.put ("key", key.prv.data.to_string ()); request.put ("account", key.pub.to_account ()); request.put ("previous", 0); - request.put ("representative", rai::test_genesis_key.pub.to_account ()); - request.put ("balance", rai::Gxrb_ratio.convert_to ()); + request.put ("representative", nano::test_genesis_key.pub.to_account ()); + request.put ("balance", nano::Gxrb_ratio.convert_to ()); request.put ("link", send_block->hash ().to_string ()); - request.put ("work", rai::to_string_hex (system.nodes[0]->work_generate_blocking (send_block->hash ()))); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + request.put ("work", nano::to_string_hex (system.nodes[0]->work_generate_blocking (send_block->hash ()))); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); @@ -3492,40 +3492,40 @@ TEST (rpc, block_create_state_open) std::stringstream block_stream (state_text); boost::property_tree::ptree block_l; boost::property_tree::read_json (block_stream, block_l); - auto state_block (rai::deserialize_block_json (block_l)); + auto state_block (nano::deserialize_block_json (block_l)); ASSERT_NE (nullptr, state_block); - ASSERT_EQ (rai::block_type::state, state_block->type ()); + ASSERT_EQ (nano::block_type::state, state_block->type ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ()); ASSERT_TRUE (system.nodes[0]->latest (key.pub).is_zero ()); auto process_result (system.nodes[0]->process (*state_block)); - ASSERT_EQ (rai::process_result::progress, process_result.code); + ASSERT_EQ (nano::process_result::progress, process_result.code); ASSERT_FALSE (system.nodes[0]->latest (key.pub).is_zero ()); } // Missing "work" parameter should cause work to be generated for us. TEST (rpc, block_create_state_request_work) { - rai::genesis genesis; + nano::genesis genesis; // Test work generation for state blocks both with and without previous (in the latter // case, the account will be used for work generation) std::vector previous_test_input{ genesis.hash ().to_string (), std::string ("0") }; for (auto previous : previous_test_input) { - rai::system system (24000, 1); - rai::keypair key; - rai::genesis genesis; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + nano::keypair key; + nano::genesis genesis; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); boost::property_tree::ptree request; request.put ("action", "block_create"); request.put ("type", "state"); request.put ("wallet", system.nodes[0]->wallets.items.begin ()->first.to_string ()); - request.put ("account", rai::test_genesis_key.pub.to_account ()); - request.put ("representative", rai::test_genesis_key.pub.to_account ()); - request.put ("balance", (rai::genesis_amount - rai::Gxrb_ratio).convert_to ()); + request.put ("account", nano::test_genesis_key.pub.to_account ()); + request.put ("representative", nano::test_genesis_key.pub.to_account ()); + request.put ("balance", (nano::genesis_amount - nano::Gxrb_ratio).convert_to ()); request.put ("link", key.pub.to_account ()); request.put ("previous", previous); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); test_response response (request, rpc, system.io_ctx); system.deadline_set (5s); @@ -3537,20 +3537,20 @@ TEST (rpc, block_create_state_request_work) boost::property_tree::ptree block_l; std::stringstream block_stream (response.json.get ("block")); boost::property_tree::read_json (block_stream, block_l); - auto block (rai::deserialize_block_json (block_l)); + auto block (nano::deserialize_block_json (block_l)); ASSERT_NE (nullptr, block); - ASSERT_FALSE (rai::work_validate (*block)); + ASSERT_FALSE (nano::work_validate (*block)); } } TEST (rpc, block_hash) { - rai::system system (24000, 1); - rai::keypair key; - auto latest (system.nodes[0]->latest (rai::test_genesis_key.pub)); + nano::system system (24000, 1); + nano::keypair key; + auto latest (system.nodes[0]->latest (nano::test_genesis_key.pub)); auto & node1 (*system.nodes[0]); - rai::send_block send (latest, key.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, node1.work_generate_blocking (latest)); - rai::rpc rpc (system.io_ctx, node1, rai::rpc_config (true)); + nano::send_block send (latest, key.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, node1.work_generate_blocking (latest)); + nano::rpc rpc (system.io_ctx, node1, nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "block_hash"); @@ -3570,8 +3570,8 @@ TEST (rpc, block_hash) TEST (rpc, wallet_lock) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; std::string wallet; @@ -3597,8 +3597,8 @@ TEST (rpc, wallet_lock) TEST (rpc, wallet_locked) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; std::string wallet; @@ -3618,13 +3618,13 @@ TEST (rpc, wallet_locked) TEST (rpc, wallet_create_fail) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); auto node = system.nodes[0]; // lmdb_max_dbs should be removed once the wallet store is refactored to support more wallets. for (int i = 0; i < 113; i++) { - rai::keypair key; + nano::keypair key; node->wallets.create (key.pub); } rpc.start (); @@ -3641,18 +3641,18 @@ TEST (rpc, wallet_create_fail) TEST (rpc, wallet_ledger) { - rai::system system (24000, 1); - rai::keypair key; - rai::genesis genesis; + nano::system system (24000, 1); + nano::keypair key; + nano::genesis genesis; system.wallet (0)->insert_adhoc (key.prv); auto & node1 (*system.nodes[0]); - auto latest (system.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::send_block send (latest, key.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, node1.work_generate_blocking (latest)); + auto latest (system.nodes[0]->latest (nano::test_genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::test_genesis_key.prv, nano::test_genesis_key.pub, node1.work_generate_blocking (latest)); system.nodes[0]->process (send); - rai::open_block open (send.hash (), rai::test_genesis_key.pub, key.pub, key.prv, key.pub, node1.work_generate_blocking (key.pub)); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (open).code); - auto time (rai::seconds_since_epoch ()); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::open_block open (send.hash (), nano::test_genesis_key.pub, key.pub, key.prv, key.pub, node1.work_generate_blocking (key.pub)); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code); + auto time (nano::seconds_since_epoch ()); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "wallet_ledger"); @@ -3713,8 +3713,8 @@ TEST (rpc, wallet_ledger) TEST (rpc, wallet_add_watch) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; std::string wallet; @@ -3723,7 +3723,7 @@ TEST (rpc, wallet_add_watch) request.put ("action", "wallet_add_watch"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", rai::test_genesis_key.pub.to_account ()); + entry.put ("", nano::test_genesis_key.pub.to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); test_response response (request, rpc, system.io_ctx); @@ -3735,21 +3735,21 @@ TEST (rpc, wallet_add_watch) ASSERT_EQ (200, response.status); std::string success (response.json.get ("success")); ASSERT_TRUE (success.empty ()); - ASSERT_TRUE (system.wallet (0)->exists (rai::test_genesis_key.pub)); + ASSERT_TRUE (system.wallet (0)->exists (nano::test_genesis_key.pub)); } TEST (rpc, online_reps) { - rai::system system (24000, 2); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 2); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); ASSERT_TRUE (system.nodes[1]->online_reps.online_stake () == system.nodes[1]->config.online_weight_minimum.number ()); - system.wallet (0)->send_action (rai::test_genesis_key.pub, rai::test_genesis_key.pub, rai::Gxrb_ratio); + system.wallet (0)->send_action (nano::test_genesis_key.pub, nano::test_genesis_key.pub, nano::Gxrb_ratio); system.deadline_set (10s); while (system.nodes[1]->online_reps.online_stake () == system.nodes[1]->config.online_weight_minimum.number ()) { ASSERT_NO_ERROR (system.poll ()); } - rai::rpc rpc (system.io_ctx, *system.nodes[1], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[1], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "representatives_online"); @@ -3764,7 +3764,7 @@ TEST (rpc, online_reps) auto representatives (response.json.get_child ("representatives")); auto item (representatives.begin ()); ASSERT_NE (representatives.end (), item); - ASSERT_EQ (rai::test_genesis_key.pub.to_account (), item->first); + ASSERT_EQ (nano::test_genesis_key.pub.to_account (), item->first); boost::optional weight (item->second.get_optional ("weight")); ASSERT_FALSE (weight.is_initialized ()); //Test weight option @@ -3777,17 +3777,17 @@ TEST (rpc, online_reps) auto representatives2 (response2.json.get_child ("representatives")); auto item2 (representatives2.begin ()); ASSERT_NE (representatives2.end (), item2); - ASSERT_EQ (rai::test_genesis_key.pub.to_account (), item2->first); + ASSERT_EQ (nano::test_genesis_key.pub.to_account (), item2->first); auto weight2 (item2->second.get ("weight")); - ASSERT_EQ (system.nodes[1]->weight (rai::test_genesis_key.pub).convert_to (), weight2); + ASSERT_EQ (system.nodes[1]->weight (nano::test_genesis_key.pub).convert_to (), weight2); //Test accounts filter - system.wallet (1)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (1)->insert_adhoc (nano::test_genesis_key.prv); auto new_rep (system.wallet (1)->deterministic_insert ()); - auto send (system.wallet (1)->send_action (rai::test_genesis_key.pub, new_rep, system.nodes[0]->config.receive_minimum.number ())); + auto send (system.wallet (1)->send_action (nano::test_genesis_key.pub, new_rep, system.nodes[0]->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); - auto receive (system.wallet (1)->receive_action (static_cast (*send), new_rep, system.nodes[0]->config.receive_minimum.number ())); + auto receive (system.wallet (1)->receive_action (static_cast (*send), new_rep, system.nodes[0]->config.receive_minimum.number ())); ASSERT_NE (nullptr, receive); - auto change (system.wallet (1)->change_action (rai::test_genesis_key.pub, new_rep)); + auto change (system.wallet (1)->change_action (nano::test_genesis_key.pub, new_rep)); ASSERT_NE (nullptr, change); system.deadline_set (5s); while (system.nodes[1]->online_reps.list ().size () != 2) @@ -3815,16 +3815,16 @@ TEST (rpc, online_reps) TEST (rpc, confirmation_history) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto block (system.wallet (0)->send_action (rai::test_genesis_key.pub, rai::test_genesis_key.pub, rai::Gxrb_ratio)); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto block (system.wallet (0)->send_action (nano::test_genesis_key.pub, nano::test_genesis_key.pub, nano::Gxrb_ratio)); ASSERT_TRUE (system.nodes[0]->active.confirmed.empty ()); system.deadline_set (10s); while (system.nodes[0]->active.confirmed.empty ()) { ASSERT_NO_ERROR (system.poll ()); } - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "confirmation_history"); @@ -3841,24 +3841,24 @@ TEST (rpc, confirmation_history) auto hash (item->second.get ("hash")); auto tally (item->second.get ("tally")); ASSERT_EQ (block->hash ().to_string (), hash); - rai::amount tally_num; + nano::amount tally_num; tally_num.decode_dec (tally); - assert (tally_num == rai::genesis_amount || tally_num == (rai::genesis_amount - rai::Gxrb_ratio)); + assert (tally_num == nano::genesis_amount || tally_num == (nano::genesis_amount - nano::Gxrb_ratio)); system.stop (); } TEST (rpc, block_confirm) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::genesis genesis; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto send1 (std::make_shared (rai::test_genesis_key.pub, genesis.hash (), rai::test_genesis_key.pub, rai::genesis_amount - rai::Gxrb_ratio, rai::test_genesis_key.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.nodes[0]->work_generate_blocking (genesis.hash ()))); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::genesis genesis; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto send1 (std::make_shared (nano::test_genesis_key.pub, genesis.hash (), nano::test_genesis_key.pub, nano::genesis_amount - nano::Gxrb_ratio, nano::test_genesis_key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.nodes[0]->work_generate_blocking (genesis.hash ()))); { auto transaction (system.nodes[0]->store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->ledger.process (transaction, *send1).code); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->ledger.process (transaction, *send1).code); } - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "block_confirm"); @@ -3875,9 +3875,9 @@ TEST (rpc, block_confirm) TEST (rpc, block_confirm_absent) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "block_confirm"); @@ -3894,8 +3894,8 @@ TEST (rpc, block_confirm_absent) TEST (rpc, node_id) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); boost::property_tree::ptree request; request.put ("action", "node_id"); @@ -3907,19 +3907,19 @@ TEST (rpc, node_id) } ASSERT_EQ (200, response.status); auto transaction (system.nodes[0]->store.tx_begin_read ()); - rai::keypair node_id (system.nodes[0]->store.get_node_id (transaction)); + nano::keypair node_id (system.nodes[0]->store.get_node_id (transaction)); ASSERT_EQ (node_id.prv.data.to_string (), response.json.get ("private")); ASSERT_EQ (node_id.pub.to_account (), response.json.get ("as_account")); } TEST (rpc, node_id_delete) { - rai::system system (24000, 1); - rai::rpc rpc (system.io_ctx, *system.nodes[0], rai::rpc_config (true)); + nano::system system (24000, 1); + nano::rpc rpc (system.io_ctx, *system.nodes[0], nano::rpc_config (true)); rpc.start (); { auto transaction (system.nodes[0]->store.tx_begin_write ()); - rai::keypair node_id (system.nodes[0]->store.get_node_id (transaction)); + nano::keypair node_id (system.nodes[0]->store.get_node_id (transaction)); ASSERT_EQ (node_id.pub.to_string (), system.nodes[0]->node_id.pub.to_string ()); } boost::property_tree::ptree request; @@ -3933,6 +3933,6 @@ TEST (rpc, node_id_delete) ASSERT_EQ (200, response.status); ASSERT_EQ ("1", response.json.get ("deleted")); auto transaction (system.nodes[0]->store.tx_begin_write ()); - rai::keypair node_id (system.nodes[0]->store.get_node_id (transaction)); + nano::keypair node_id (system.nodes[0]->store.get_node_id (transaction)); ASSERT_NE (node_id.pub.to_string (), system.nodes[0]->node_id.pub.to_string ()); } diff --git a/rai/core_test/signing.cpp b/nano/core_test/signing.cpp similarity index 67% rename from rai/core_test/signing.cpp rename to nano/core_test/signing.cpp index 710ff8f3..c86c4e4b 100644 --- a/rai/core_test/signing.cpp +++ b/nano/core_test/signing.cpp @@ -1,24 +1,24 @@ #include #include -#include +#include TEST (signature_checker, empty) { - rai::signature_checker checker; + nano::signature_checker checker; std::promise promise; - rai::signature_check_set check = { 0, nullptr, nullptr, nullptr, nullptr, nullptr, &promise }; + nano::signature_check_set check = { 0, nullptr, nullptr, nullptr, nullptr, nullptr, &promise }; checker.add (check); promise.get_future ().wait (); } TEST (signature_checker, many) { - rai::keypair key; - rai::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0); - rai::signature_checker checker; + nano::keypair key; + nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0); + nano::signature_checker checker; std::promise promise; - std::vector hashes; + std::vector hashes; size_t size (1000); hashes.reserve (size); std::vector messages; @@ -39,18 +39,18 @@ TEST (signature_checker, many) pub_keys.push_back (block.hashables.account.bytes.data ()); signatures.push_back (block.signature.bytes.data ()); } - rai::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data (), &promise }; + nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data (), &promise }; checker.add (check); promise.get_future ().wait (); } TEST (signature_checker, one) { - rai::keypair key; - rai::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0); - rai::signature_checker checker; + nano::keypair key; + nano::state_block block (key.pub, 0, key.pub, 0, 0, key.prv, key.pub, 0); + nano::signature_checker checker; std::promise promise; - std::vector hashes; + std::vector hashes; std::vector messages; std::vector lengths; std::vector pub_keys; @@ -66,7 +66,7 @@ TEST (signature_checker, one) pub_keys.push_back (block.hashables.account.bytes.data ()); signatures.push_back (block.signature.bytes.data ()); } - rai::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data (), &promise }; + nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data (), &promise }; checker.add (check); promise.get_future ().wait (); } diff --git a/rai/core_test/test_messages.cpp b/nano/core_test/test_messages.cpp similarity index 100% rename from rai/core_test/test_messages.cpp rename to nano/core_test/test_messages.cpp diff --git a/rai/core_test/testutil.hpp b/nano/core_test/testutil.hpp similarity index 100% rename from rai/core_test/testutil.hpp rename to nano/core_test/testutil.hpp diff --git a/rai/core_test/uint256_union.cpp b/nano/core_test/uint256_union.cpp similarity index 61% rename from rai/core_test/uint256_union.cpp rename to nano/core_test/uint256_union.cpp index 3356d52e..2eac2584 100644 --- a/rai/core_test/uint256_union.cpp +++ b/nano/core_test/uint256_union.cpp @@ -1,7 +1,7 @@ #include -#include -#include +#include +#include namespace { @@ -23,7 +23,7 @@ void check_operator_greater_than (Num lhs, Num rhs); TEST (uint128_union, decode_dec) { - rai::uint128_union value; + nano::uint128_union value; std::string text ("16"); ASSERT_FALSE (value.decode_dec (text)); ASSERT_EQ (16, value.bytes[15]); @@ -31,7 +31,7 @@ TEST (uint128_union, decode_dec) TEST (uint128_union, decode_dec_negative) { - rai::uint128_union value; + nano::uint128_union value; std::string text ("-1"); auto error (value.decode_dec (text)); ASSERT_TRUE (error); @@ -39,7 +39,7 @@ TEST (uint128_union, decode_dec_negative) TEST (uint128_union, decode_dec_zero) { - rai::uint128_union value; + nano::uint128_union value; std::string text ("0"); ASSERT_FALSE (value.decode_dec (text)); ASSERT_TRUE (value.is_zero ()); @@ -47,7 +47,7 @@ TEST (uint128_union, decode_dec_zero) TEST (uint128_union, decode_dec_leading_zero) { - rai::uint128_union value; + nano::uint128_union value; std::string text ("010"); auto error (value.decode_dec (text)); ASSERT_TRUE (error); @@ -55,7 +55,7 @@ TEST (uint128_union, decode_dec_leading_zero) TEST (uint128_union, decode_dec_overflow) { - rai::uint128_union value; + nano::uint128_union value; std::string text ("340282366920938463463374607431768211456"); auto error (value.decode_dec (text)); ASSERT_TRUE (error); @@ -63,12 +63,12 @@ TEST (uint128_union, decode_dec_overflow) TEST (uint128_union, operator_less_than) { - test_union_operator_less_than (); + test_union_operator_less_than (); } TEST (uint128_union, operator_greater_than) { - test_union_operator_greater_than (); + test_union_operator_greater_than (); } struct test_punct : std::moneypunct @@ -97,66 +97,66 @@ struct test_punct : std::moneypunct TEST (uint128_union, balance_format) { - ASSERT_EQ ("0", rai::amount (rai::uint128_t ("0")).format_balance (rai::Mxrb_ratio, 0, false)); - ASSERT_EQ ("0", rai::amount (rai::uint128_t ("0")).format_balance (rai::Mxrb_ratio, 2, true)); - ASSERT_EQ ("340,282,366", rai::amount (rai::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")).format_balance (rai::Mxrb_ratio, 0, true)); - ASSERT_EQ ("340,282,366.920938463463374607431768211455", rai::amount (rai::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")).format_balance (rai::Mxrb_ratio, 64, true)); - ASSERT_EQ ("340,282,366,920,938,463,463,374,607,431,768,211,455", rai::amount (rai::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")).format_balance (1, 4, true)); - ASSERT_EQ ("340,282,366", rai::amount (rai::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (rai::Mxrb_ratio, 0, true)); - ASSERT_EQ ("340,282,366.920938463463374607431768211454", rai::amount (rai::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (rai::Mxrb_ratio, 64, true)); - ASSERT_EQ ("340282366920938463463374607431768211454", rai::amount (rai::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (1, 4, false)); - ASSERT_EQ ("170,141,183", rai::amount (rai::uint128_t ("0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (rai::Mxrb_ratio, 0, true)); - ASSERT_EQ ("170,141,183.460469231731687303715884105726", rai::amount (rai::uint128_t ("0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (rai::Mxrb_ratio, 64, true)); - ASSERT_EQ ("170141183460469231731687303715884105726", rai::amount (rai::uint128_t ("0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (1, 4, false)); - ASSERT_EQ ("1", rai::amount (rai::uint128_t ("1000000000000000000000000000000")).format_balance (rai::Mxrb_ratio, 2, true)); - ASSERT_EQ ("1.2", rai::amount (rai::uint128_t ("1200000000000000000000000000000")).format_balance (rai::Mxrb_ratio, 2, true)); - ASSERT_EQ ("1.23", rai::amount (rai::uint128_t ("1230000000000000000000000000000")).format_balance (rai::Mxrb_ratio, 2, true)); - ASSERT_EQ ("1.2", rai::amount (rai::uint128_t ("1230000000000000000000000000000")).format_balance (rai::Mxrb_ratio, 1, true)); - ASSERT_EQ ("1", rai::amount (rai::uint128_t ("1230000000000000000000000000000")).format_balance (rai::Mxrb_ratio, 0, true)); - ASSERT_EQ ("< 0.01", rai::amount (rai::xrb_ratio * 10).format_balance (rai::Mxrb_ratio, 2, true)); - ASSERT_EQ ("< 0.1", rai::amount (rai::xrb_ratio * 10).format_balance (rai::Mxrb_ratio, 1, true)); - ASSERT_EQ ("< 1", rai::amount (rai::xrb_ratio * 10).format_balance (rai::Mxrb_ratio, 0, true)); - ASSERT_EQ ("< 0.01", rai::amount (rai::xrb_ratio * 9999).format_balance (rai::Mxrb_ratio, 2, true)); - ASSERT_EQ ("0.01", rai::amount (rai::xrb_ratio * 10000).format_balance (rai::Mxrb_ratio, 2, true)); - ASSERT_EQ ("123456789", rai::amount (rai::Mxrb_ratio * 123456789).format_balance (rai::Mxrb_ratio, 2, false)); - ASSERT_EQ ("123,456,789", rai::amount (rai::Mxrb_ratio * 123456789).format_balance (rai::Mxrb_ratio, 2, true)); - ASSERT_EQ ("123,456,789.12", rai::amount (rai::Mxrb_ratio * 123456789 + rai::kxrb_ratio * 123).format_balance (rai::Mxrb_ratio, 2, true)); - ASSERT_EQ ("12-3456-789+123", rai::amount (rai::Mxrb_ratio * 123456789 + rai::kxrb_ratio * 123).format_balance (rai::Mxrb_ratio, 4, true, std::locale (std::cout.getloc (), new test_punct))); + ASSERT_EQ ("0", nano::amount (nano::uint128_t ("0")).format_balance (nano::Mxrb_ratio, 0, false)); + ASSERT_EQ ("0", nano::amount (nano::uint128_t ("0")).format_balance (nano::Mxrb_ratio, 2, true)); + ASSERT_EQ ("340,282,366", nano::amount (nano::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")).format_balance (nano::Mxrb_ratio, 0, true)); + ASSERT_EQ ("340,282,366.920938463463374607431768211455", nano::amount (nano::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")).format_balance (nano::Mxrb_ratio, 64, true)); + ASSERT_EQ ("340,282,366,920,938,463,463,374,607,431,768,211,455", nano::amount (nano::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")).format_balance (1, 4, true)); + ASSERT_EQ ("340,282,366", nano::amount (nano::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (nano::Mxrb_ratio, 0, true)); + ASSERT_EQ ("340,282,366.920938463463374607431768211454", nano::amount (nano::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (nano::Mxrb_ratio, 64, true)); + ASSERT_EQ ("340282366920938463463374607431768211454", nano::amount (nano::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (1, 4, false)); + ASSERT_EQ ("170,141,183", nano::amount (nano::uint128_t ("0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (nano::Mxrb_ratio, 0, true)); + ASSERT_EQ ("170,141,183.460469231731687303715884105726", nano::amount (nano::uint128_t ("0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (nano::Mxrb_ratio, 64, true)); + ASSERT_EQ ("170141183460469231731687303715884105726", nano::amount (nano::uint128_t ("0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (1, 4, false)); + ASSERT_EQ ("1", nano::amount (nano::uint128_t ("1000000000000000000000000000000")).format_balance (nano::Mxrb_ratio, 2, true)); + ASSERT_EQ ("1.2", nano::amount (nano::uint128_t ("1200000000000000000000000000000")).format_balance (nano::Mxrb_ratio, 2, true)); + ASSERT_EQ ("1.23", nano::amount (nano::uint128_t ("1230000000000000000000000000000")).format_balance (nano::Mxrb_ratio, 2, true)); + ASSERT_EQ ("1.2", nano::amount (nano::uint128_t ("1230000000000000000000000000000")).format_balance (nano::Mxrb_ratio, 1, true)); + ASSERT_EQ ("1", nano::amount (nano::uint128_t ("1230000000000000000000000000000")).format_balance (nano::Mxrb_ratio, 0, true)); + ASSERT_EQ ("< 0.01", nano::amount (nano::xrb_ratio * 10).format_balance (nano::Mxrb_ratio, 2, true)); + ASSERT_EQ ("< 0.1", nano::amount (nano::xrb_ratio * 10).format_balance (nano::Mxrb_ratio, 1, true)); + ASSERT_EQ ("< 1", nano::amount (nano::xrb_ratio * 10).format_balance (nano::Mxrb_ratio, 0, true)); + ASSERT_EQ ("< 0.01", nano::amount (nano::xrb_ratio * 9999).format_balance (nano::Mxrb_ratio, 2, true)); + ASSERT_EQ ("0.01", nano::amount (nano::xrb_ratio * 10000).format_balance (nano::Mxrb_ratio, 2, true)); + ASSERT_EQ ("123456789", nano::amount (nano::Mxrb_ratio * 123456789).format_balance (nano::Mxrb_ratio, 2, false)); + ASSERT_EQ ("123,456,789", nano::amount (nano::Mxrb_ratio * 123456789).format_balance (nano::Mxrb_ratio, 2, true)); + ASSERT_EQ ("123,456,789.12", nano::amount (nano::Mxrb_ratio * 123456789 + nano::kxrb_ratio * 123).format_balance (nano::Mxrb_ratio, 2, true)); + ASSERT_EQ ("12-3456-789+123", nano::amount (nano::Mxrb_ratio * 123456789 + nano::kxrb_ratio * 123).format_balance (nano::Mxrb_ratio, 4, true, std::locale (std::cout.getloc (), new test_punct))); } TEST (unions, identity) { - ASSERT_EQ (1, rai::uint128_union (1).number ().convert_to ()); - ASSERT_EQ (1, rai::uint256_union (1).number ().convert_to ()); - ASSERT_EQ (1, rai::uint512_union (1).number ().convert_to ()); + ASSERT_EQ (1, nano::uint128_union (1).number ().convert_to ()); + ASSERT_EQ (1, nano::uint256_union (1).number ().convert_to ()); + ASSERT_EQ (1, nano::uint512_union (1).number ().convert_to ()); } TEST (uint256_union, key_encryption) { - rai::keypair key1; - rai::raw_key secret_key; + nano::keypair key1; + nano::raw_key secret_key; secret_key.data.bytes.fill (0); - rai::uint256_union encrypted; + nano::uint256_union encrypted; encrypted.encrypt (key1.prv, secret_key, key1.pub.owords[0]); - rai::raw_key key4; + nano::raw_key key4; key4.decrypt (encrypted, secret_key, key1.pub.owords[0]); ASSERT_EQ (key1.prv, key4); - rai::public_key pub (rai::pub_key (key4.data)); + nano::public_key pub (nano::pub_key (key4.data)); ASSERT_EQ (key1.pub, pub); } TEST (uint256_union, encryption) { - rai::raw_key key; + nano::raw_key key; key.data.clear (); - rai::raw_key number1; + nano::raw_key number1; number1.data = 1; - rai::uint256_union encrypted1; + nano::uint256_union encrypted1; encrypted1.encrypt (number1, key, key.data.owords[0]); - rai::uint256_union encrypted2; + nano::uint256_union encrypted2; encrypted2.encrypt (number1, key, key.data.owords[0]); ASSERT_EQ (encrypted1, encrypted2); - rai::raw_key number2; + nano::raw_key number2; number2.decrypt (encrypted1, key, key.data.owords[0]); ASSERT_EQ (number1, number2); } @@ -164,16 +164,16 @@ TEST (uint256_union, encryption) TEST (uint256_union, decode_empty) { std::string text; - rai::uint256_union val; + nano::uint256_union val; ASSERT_TRUE (val.decode_hex (text)); } TEST (uint256_union, parse_zero) { - rai::uint256_union input (rai::uint256_t (0)); + nano::uint256_union input (nano::uint256_t (0)); std::string text; input.encode_hex (text); - rai::uint256_union output; + nano::uint256_union output; auto error (output.decode_hex (text)); ASSERT_FALSE (error); ASSERT_EQ (input, output); @@ -183,7 +183,7 @@ TEST (uint256_union, parse_zero) TEST (uint256_union, parse_zero_short) { std::string text ("0"); - rai::uint256_union output; + nano::uint256_union output; auto error (output.decode_hex (text)); ASSERT_FALSE (error); ASSERT_TRUE (output.number ().is_zero ()); @@ -191,10 +191,10 @@ TEST (uint256_union, parse_zero_short) TEST (uint256_union, parse_one) { - rai::uint256_union input (rai::uint256_t (1)); + nano::uint256_union input (nano::uint256_t (1)); std::string text; input.encode_hex (text); - rai::uint256_union output; + nano::uint256_union output; auto error (output.decode_hex (text)); ASSERT_FALSE (error); ASSERT_EQ (input, output); @@ -203,30 +203,30 @@ TEST (uint256_union, parse_one) TEST (uint256_union, parse_error_symbol) { - rai::uint256_union input (rai::uint256_t (1000)); + nano::uint256_union input (nano::uint256_t (1000)); std::string text; input.encode_hex (text); text[5] = '!'; - rai::uint256_union output; + nano::uint256_union output; auto error (output.decode_hex (text)); ASSERT_TRUE (error); } TEST (uint256_union, max_hex) { - rai::uint256_union input (std::numeric_limits::max ()); + nano::uint256_union input (std::numeric_limits::max ()); std::string text; input.encode_hex (text); - rai::uint256_union output; + nano::uint256_union output; auto error (output.decode_hex (text)); ASSERT_FALSE (error); ASSERT_EQ (input, output); - ASSERT_EQ (rai::uint256_t ("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), output.number ()); + ASSERT_EQ (nano::uint256_t ("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), output.number ()); } TEST (uint256_union, decode_dec) { - rai::uint256_union value; + nano::uint256_union value; std::string text ("16"); ASSERT_FALSE (value.decode_dec (text)); ASSERT_EQ (16, value.bytes[31]); @@ -234,19 +234,19 @@ TEST (uint256_union, decode_dec) TEST (uint256_union, max_dec) { - rai::uint256_union input (std::numeric_limits::max ()); + nano::uint256_union input (std::numeric_limits::max ()); std::string text; input.encode_dec (text); - rai::uint256_union output; + nano::uint256_union output; auto error (output.decode_dec (text)); ASSERT_FALSE (error); ASSERT_EQ (input, output); - ASSERT_EQ (rai::uint256_t ("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), output.number ()); + ASSERT_EQ (nano::uint256_t ("0xffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"), output.number ()); } TEST (uint256_union, decode_dec_negative) { - rai::uint256_union value; + nano::uint256_union value; std::string text ("-1"); auto error (value.decode_dec (text)); ASSERT_TRUE (error); @@ -254,7 +254,7 @@ TEST (uint256_union, decode_dec_negative) TEST (uint256_union, decode_dec_zero) { - rai::uint256_union value; + nano::uint256_union value; std::string text ("0"); ASSERT_FALSE (value.decode_dec (text)); ASSERT_TRUE (value.is_zero ()); @@ -262,7 +262,7 @@ TEST (uint256_union, decode_dec_zero) TEST (uint256_union, decode_dec_leading_zero) { - rai::uint256_union value; + nano::uint256_union value; std::string text ("010"); auto error (value.decode_dec (text)); ASSERT_TRUE (error); @@ -270,28 +270,28 @@ TEST (uint256_union, decode_dec_leading_zero) TEST (uint256_union, parse_error_overflow) { - rai::uint256_union input (std::numeric_limits::max ()); + nano::uint256_union input (std::numeric_limits::max ()); std::string text; input.encode_hex (text); text.push_back (0); - rai::uint256_union output; + nano::uint256_union output; auto error (output.decode_hex (text)); ASSERT_TRUE (error); } TEST (uint256_union, big_endian_union_constructor) { - rai::uint256_t value1 (1); - rai::uint256_union bytes1 (value1); + nano::uint256_t value1 (1); + nano::uint256_union bytes1 (value1); ASSERT_EQ (1, bytes1.bytes[31]); - rai::uint512_t value2 (1); - rai::uint512_union bytes2 (value2); + nano::uint512_t value2 (1); + nano::uint512_union bytes2 (value2); ASSERT_EQ (1, bytes2.bytes[63]); } TEST (uint256_union, big_endian_union_function) { - rai::uint256_union bytes1 ("FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210"); + nano::uint256_union bytes1 ("FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210"); ASSERT_EQ (0xfe, bytes1.bytes[0x00]); ASSERT_EQ (0xdc, bytes1.bytes[0x01]); ASSERT_EQ (0xba, bytes1.bytes[0x02]); @@ -325,16 +325,16 @@ TEST (uint256_union, big_endian_union_function) ASSERT_EQ (0x32, bytes1.bytes[0x1e]); ASSERT_EQ (0x10, bytes1.bytes[0x1f]); ASSERT_EQ ("FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210", bytes1.to_string ()); - ASSERT_EQ (rai::uint256_t ("0xFEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210"), bytes1.number ()); - rai::uint512_union bytes2; + ASSERT_EQ (nano::uint256_t ("0xFEDCBA9876543210FEDCBA9876543210FEDCBA9876543210FEDCBA9876543210"), bytes1.number ()); + nano::uint512_union bytes2; bytes2.clear (); bytes2.bytes[63] = 1; - ASSERT_EQ (rai::uint512_t (1), bytes2.number ()); + ASSERT_EQ (nano::uint512_t (1), bytes2.number ()); } TEST (uint256_union, decode_nano_variant) { - rai::uint256_union key; + nano::uint256_union key; ASSERT_FALSE (key.decode_account ("xrb_1111111111111111111111111111111111111111111111111111hifc8npp")); ASSERT_FALSE (key.decode_account ("nano_1111111111111111111111111111111111111111111111111111hifc8npp")); } @@ -343,9 +343,9 @@ TEST (uint256_union, decode_account_variations) { for (int i = 0; i < 100; i++) { - rai::raw_key key; + nano::raw_key key; xrb_generate_random (key.data.bytes.data ()); - rai::uint256_union pub; + nano::uint256_union pub; xrb_key_account (key.data.bytes.data (), pub.bytes.data ()); char account[65] = { 0 }; @@ -365,21 +365,21 @@ TEST (uint256_union, decode_account_variations) TEST (uint256_union, account_transcode) { - rai::uint256_union value; - auto text (rai::test_genesis_key.pub.to_account ()); + nano::uint256_union value; + auto text (nano::test_genesis_key.pub.to_account ()); ASSERT_FALSE (value.decode_account (text)); - ASSERT_EQ (rai::test_genesis_key.pub, value); + ASSERT_EQ (nano::test_genesis_key.pub, value); ASSERT_EQ ('_', text[3]); text[3] = '-'; - rai::uint256_union value2; + nano::uint256_union value2; ASSERT_FALSE (value2.decode_account (text)); ASSERT_EQ (value, value2); } TEST (uint256_union, account_encode_lex) { - rai::uint256_union min ("0000000000000000000000000000000000000000000000000000000000000000"); - rai::uint256_union max ("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); + nano::uint256_union min ("0000000000000000000000000000000000000000000000000000000000000000"); + nano::uint256_union max ("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); auto min_text (min.to_account ()); ASSERT_EQ (64, min_text.size ()); auto max_text (max.to_account ()); @@ -387,9 +387,9 @@ TEST (uint256_union, account_encode_lex) auto previous (min_text); for (auto i (1); i != 1000; ++i) { - rai::uint256_union number (min.number () + i); + nano::uint256_union number (min.number () + i); auto text (number.to_account ()); - rai::uint256_union output; + nano::uint256_union output; output.decode_account (text); ASSERT_EQ (number, output); ASSERT_GT (text, previous); @@ -397,9 +397,9 @@ TEST (uint256_union, account_encode_lex) } for (auto i (1); i != 1000; ++i) { - rai::keypair key; + nano::keypair key; auto text (key.pub.to_account ()); - rai::uint256_union output; + nano::uint256_union output; output.decode_account (text); ASSERT_EQ (key.pub, output); } @@ -407,7 +407,7 @@ TEST (uint256_union, account_encode_lex) TEST (uint256_union, bounds) { - rai::uint256_union key; + nano::uint256_union key; std::string bad1 (64, '\x000'); bad1[0] = 'x'; bad1[1] = 'r'; @@ -424,7 +424,7 @@ TEST (uint256_union, bounds) TEST (uint256_union, operator_less_than) { - test_union_operator_less_than (); + test_union_operator_less_than (); } class json_upgrade_test @@ -461,43 +461,43 @@ public: TEST (json, fetch_object) { - auto path1 (rai::unique_path ()); + auto path1 (nano::unique_path ()); std::fstream stream1; - rai::open_or_create (stream1, path1.string ()); + nano::open_or_create (stream1, path1.string ()); stream1 << "{ \"thing\": \"junktest\" }"; stream1.close (); - rai::open_or_create (stream1, path1.string ()); + nano::open_or_create (stream1, path1.string ()); json_upgrade_test object1; - auto error1 (rai::fetch_object (object1, path1, stream1)); + auto error1 (nano::fetch_object (object1, path1, stream1)); ASSERT_FALSE (error1); ASSERT_EQ ("changed", object1.text); boost::property_tree::ptree tree1; stream1.close (); - rai::open_or_create (stream1, path1.string ()); + nano::open_or_create (stream1, path1.string ()); boost::property_tree::read_json (stream1, tree1); ASSERT_EQ ("changed", tree1.get ("thing")); std::string string2 ("{ \"thing\": \"junktest2\" }"); std::stringstream stream2 (string2); json_upgrade_test object2; - auto error2 (rai::fetch_object (object2, stream2)); + auto error2 (nano::fetch_object (object2, stream2)); ASSERT_FALSE (error2); ASSERT_EQ ("junktest2", object2.text); ASSERT_EQ ("{ \"thing\": \"junktest2\" }", string2); std::string string3 ("{ \"thing\": \"error\" }"); std::stringstream stream3 (string3); json_upgrade_test object3; - auto error3 (rai::fetch_object (object3, stream3)); + auto error3 (nano::fetch_object (object3, stream3)); ASSERT_TRUE (error3); - auto path2 (rai::unique_path ()); + auto path2 (nano::unique_path ()); std::fstream stream4; - rai::open_or_create (stream4, path2.string ()); + nano::open_or_create (stream4, path2.string ()); json_upgrade_test object4; - auto error4 (rai::fetch_object (object4, path2, stream4)); + auto error4 (nano::fetch_object (object4, path2, stream4)); ASSERT_FALSE (error4); ASSERT_EQ ("created", object4.text); boost::property_tree::ptree tree2; stream4.close (); - rai::open_or_create (stream4, path2.string ()); + nano::open_or_create (stream4, path2.string ()); boost::property_tree::read_json (stream4, tree2); ASSERT_EQ ("created", tree2.get ("thing")); } @@ -507,24 +507,24 @@ TEST (json, DISABLED_fetch_write_fail) std::string string4 (""); std::stringstream stream4 (string4, std::ios_base::in); json_upgrade_test object4; - auto error4 (rai::fetch_object (object4, stream4)); + auto error4 (nano::fetch_object (object4, stream4)); ASSERT_TRUE (error4); } TEST (uint64_t, parse) { uint64_t value0 (1); - ASSERT_FALSE (rai::from_string_hex ("0", value0)); + ASSERT_FALSE (nano::from_string_hex ("0", value0)); ASSERT_EQ (0, value0); uint64_t value1 (1); - ASSERT_FALSE (rai::from_string_hex ("ffffffffffffffff", value1)); + ASSERT_FALSE (nano::from_string_hex ("ffffffffffffffff", value1)); ASSERT_EQ (0xffffffffffffffffULL, value1); uint64_t value2 (1); - ASSERT_TRUE (rai::from_string_hex ("g", value2)); + ASSERT_TRUE (nano::from_string_hex ("g", value2)); uint64_t value3 (1); - ASSERT_TRUE (rai::from_string_hex ("ffffffffffffffff0", value3)); + ASSERT_TRUE (nano::from_string_hex ("ffffffffffffffff0", value3)); uint64_t value4 (1); - ASSERT_TRUE (rai::from_string_hex ("", value4)); + ASSERT_TRUE (nano::from_string_hex ("", value4)); } namespace @@ -532,7 +532,7 @@ namespace template void assert_union_types () { - static_assert ((std::is_same::value && std::is_same::value) || (std::is_same::value && std::is_same::value) || (std::is_same::value && std::is_same::value), + static_assert ((std::is_same::value && std::is_same::value) || (std::is_same::value && std::is_same::value) || (std::is_same::value && std::is_same::value), "Union type needs to be consistent with the lower/upper Bound type"); } diff --git a/rai/core_test/versioning.cpp b/nano/core_test/versioning.cpp similarity index 63% rename from rai/core_test/versioning.cpp rename to nano/core_test/versioning.cpp index a65e321c..138525b1 100644 --- a/rai/core_test/versioning.cpp +++ b/nano/core_test/versioning.cpp @@ -1,30 +1,30 @@ #include -#include -#include +#include +#include TEST (versioning, account_info_v1) { - auto file (rai::unique_path ()); - rai::account account (1); - rai::open_block open (1, 2, 3, nullptr); - rai::account_info_v1 v1 (open.hash (), open.hash (), 3, 4); + auto file (nano::unique_path ()); + nano::account account (1); + nano::open_block open (1, 2, 3, nullptr); + nano::account_info_v1 v1 (open.hash (), open.hash (), 3, 4); { auto error (false); - rai::mdb_store store (error, file); + nano::mdb_store store (error, file); ASSERT_FALSE (error); auto transaction (store.tx_begin (true)); store.block_put (transaction, open.hash (), open); - auto status (mdb_put (store.env.tx (transaction), store.accounts_v0, rai::mdb_val (account), v1.val (), 0)); + auto status (mdb_put (store.env.tx (transaction), store.accounts_v0, nano::mdb_val (account), v1.val (), 0)); ASSERT_EQ (0, status); store.version_put (transaction, 1); } { auto error (false); - rai::mdb_store store (error, file); + nano::mdb_store store (error, file); ASSERT_FALSE (error); auto transaction (store.tx_begin ()); - rai::account_info v2; + nano::account_info v2; ASSERT_FALSE (store.account_get (transaction, account, v2)); ASSERT_EQ (open.hash (), v2.open_block); ASSERT_EQ (v1.balance, v2.balance); diff --git a/rai/core_test/wallet.cpp b/nano/core_test/wallet.cpp similarity index 61% rename from rai/core_test/wallet.cpp rename to nano/core_test/wallet.cpp index febbab72..f9292f37 100644 --- a/rai/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -1,22 +1,22 @@ #include #include -#include -#include +#include +#include using namespace std::chrono_literals; TEST (wallet, no_key) { bool init; - rai::mdb_env env (init, rai::unique_path ()); + nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (init); - rai::keypair key1; - rai::raw_key prv1; + nano::keypair key1; + nano::raw_key prv1; ASSERT_TRUE (wallet.fetch (transaction, key1.pub, prv1)); ASSERT_TRUE (wallet.valid_password (transaction)); } @@ -24,21 +24,21 @@ TEST (wallet, no_key) TEST (wallet, fetch_locked) { bool init; - rai::mdb_env env (init, rai::unique_path ()); + nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_TRUE (wallet.valid_password (transaction)); - rai::keypair key1; + nano::keypair key1; ASSERT_EQ (key1.pub, wallet.insert_adhoc (transaction, key1.prv)); auto key2 (wallet.deterministic_insert (transaction)); ASSERT_FALSE (key2.is_zero ()); - rai::raw_key key3; + nano::raw_key key3; key3.data = 1; wallet.password.value_set (key3); ASSERT_FALSE (wallet.valid_password (transaction)); - rai::raw_key key4; + nano::raw_key key4; ASSERT_TRUE (wallet.fetch (transaction, key1.pub, key4)); ASSERT_TRUE (wallet.fetch (transaction, key2, key4)); } @@ -46,21 +46,21 @@ TEST (wallet, fetch_locked) TEST (wallet, retrieval) { bool init; - rai::mdb_env env (init, rai::unique_path ()); + nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (init); - rai::keypair key1; + nano::keypair key1; ASSERT_TRUE (wallet.valid_password (transaction)); wallet.insert_adhoc (transaction, key1.prv); - rai::raw_key prv1; + nano::raw_key prv1; ASSERT_FALSE (wallet.fetch (transaction, key1.pub, prv1)); ASSERT_TRUE (wallet.valid_password (transaction)); ASSERT_EQ (key1.prv, prv1); wallet.password.values[0]->bytes[16] ^= 1; - rai::raw_key prv2; + nano::raw_key prv2; ASSERT_TRUE (wallet.fetch (transaction, key1.pub, prv2)); ASSERT_FALSE (wallet.valid_password (transaction)); } @@ -68,11 +68,11 @@ TEST (wallet, retrieval) TEST (wallet, empty_iteration) { bool init; - rai::mdb_env env (init, rai::unique_path ()); + nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (init); auto i (wallet.begin (transaction)); auto j (wallet.end ()); @@ -82,21 +82,21 @@ TEST (wallet, empty_iteration) TEST (wallet, one_item_iteration) { bool init; - rai::mdb_env env (init, rai::unique_path ()); + nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (init); - rai::keypair key1; + nano::keypair key1; wallet.insert_adhoc (transaction, key1.prv); for (auto i (wallet.begin (transaction)), j (wallet.end ()); i != j; ++i) { - ASSERT_EQ (key1.pub, rai::uint256_union (i->first)); - rai::raw_key password; + ASSERT_EQ (key1.pub, nano::uint256_union (i->first)); + nano::raw_key password; wallet.wallet_key (password, transaction); - rai::raw_key key; - key.decrypt (rai::wallet_value (i->second).key, password, (rai::uint256_union (i->first)).owords[0].number ()); + nano::raw_key key; + key.decrypt (nano::wallet_value (i->second).key, password, (nano::uint256_union (i->first)).owords[0].number ()); ASSERT_EQ (key1.prv, key); } } @@ -104,27 +104,27 @@ TEST (wallet, one_item_iteration) TEST (wallet, two_item_iteration) { bool init; - rai::mdb_env env (init, rai::unique_path ()); + nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); - rai::keypair key1; - rai::keypair key2; + nano::keypair key1; + nano::keypair key2; ASSERT_NE (key1.pub, key2.pub); - std::unordered_set pubs; - std::unordered_set prvs; - rai::kdf kdf; + std::unordered_set pubs; + std::unordered_set prvs; + nano::kdf kdf; { - rai::transaction transaction (env.tx_begin (true)); - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); + nano::transaction transaction (env.tx_begin (true)); + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (init); wallet.insert_adhoc (transaction, key1.prv); wallet.insert_adhoc (transaction, key2.prv); for (auto i (wallet.begin (transaction)), j (wallet.end ()); i != j; ++i) { - pubs.insert (rai::uint256_union (i->first)); - rai::raw_key password; + pubs.insert (nano::uint256_union (i->first)); + nano::raw_key password; wallet.wallet_key (password, transaction); - rai::raw_key key; - key.decrypt (rai::wallet_value (i->second).key, password, (rai::uint256_union (i->first)).owords[0].number ()); + nano::raw_key key; + key.decrypt (nano::wallet_value (i->second).key, password, (nano::uint256_union (i->first)).owords[0].number ()); prvs.insert (key.data); } } @@ -138,138 +138,138 @@ TEST (wallet, two_item_iteration) TEST (wallet, insufficient_spend_one) { - rai::system system (24000, 1); - rai::keypair key1; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto block (system.wallet (0)->send_action (rai::test_genesis_key.pub, key1.pub, 500)); + nano::system system (24000, 1); + nano::keypair key1; + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto block (system.wallet (0)->send_action (nano::test_genesis_key.pub, key1.pub, 500)); ASSERT_NE (nullptr, block); - ASSERT_EQ (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key1.pub, rai::genesis_amount)); + ASSERT_EQ (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key1.pub, nano::genesis_amount)); } TEST (wallet, spend_all_one) { - rai::system system (24000, 1); - rai::block_hash latest1 (system.nodes[0]->latest (rai::test_genesis_key.pub)); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key2; - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, std::numeric_limits::max ())); - rai::account_info info2; + nano::system system (24000, 1); + nano::block_hash latest1 (system.nodes[0]->latest (nano::test_genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key2; + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, std::numeric_limits::max ())); + nano::account_info info2; { auto transaction (system.nodes[0]->store.tx_begin ()); - system.nodes[0]->store.account_get (transaction, rai::test_genesis_key.pub, info2); + system.nodes[0]->store.account_get (transaction, nano::test_genesis_key.pub, info2); ASSERT_NE (latest1, info2.head); auto block (system.nodes[0]->store.block_get (transaction, info2.head)); ASSERT_NE (nullptr, block); ASSERT_EQ (latest1, block->previous ()); } ASSERT_TRUE (info2.balance.is_zero ()); - ASSERT_EQ (0, system.nodes[0]->balance (rai::test_genesis_key.pub)); + ASSERT_EQ (0, system.nodes[0]->balance (nano::test_genesis_key.pub)); } TEST (wallet, send_async) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key2; + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key2; boost::thread thread ([&system]() { system.deadline_set (10s); - while (!system.nodes[0]->balance (rai::test_genesis_key.pub).is_zero ()) + while (!system.nodes[0]->balance (nano::test_genesis_key.pub).is_zero ()) { ASSERT_NO_ERROR (system.poll ()); } }); bool success (false); - system.wallet (0)->send_async (rai::test_genesis_key.pub, key2.pub, std::numeric_limits::max (), [&success](std::shared_ptr block_a) { ASSERT_NE (nullptr, block_a); success = true; }); + system.wallet (0)->send_async (nano::test_genesis_key.pub, key2.pub, std::numeric_limits::max (), [&success](std::shared_ptr block_a) { ASSERT_NE (nullptr, block_a); success = true; }); thread.join (); ASSERT_TRUE (success); } TEST (wallet, spend) { - rai::system system (24000, 1); - rai::block_hash latest1 (system.nodes[0]->latest (rai::test_genesis_key.pub)); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key2; + nano::system system (24000, 1); + nano::block_hash latest1 (system.nodes[0]->latest (nano::test_genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key2; // Sending from empty accounts should always be an error. Accounts need to be opened with an open block, not a send block. ASSERT_EQ (nullptr, system.wallet (0)->send_action (0, key2.pub, 0)); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, std::numeric_limits::max ())); - rai::account_info info2; + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, std::numeric_limits::max ())); + nano::account_info info2; { auto transaction (system.nodes[0]->store.tx_begin ()); - system.nodes[0]->store.account_get (transaction, rai::test_genesis_key.pub, info2); + system.nodes[0]->store.account_get (transaction, nano::test_genesis_key.pub, info2); ASSERT_NE (latest1, info2.head); auto block (system.nodes[0]->store.block_get (transaction, info2.head)); ASSERT_NE (nullptr, block); ASSERT_EQ (latest1, block->previous ()); } ASSERT_TRUE (info2.balance.is_zero ()); - ASSERT_EQ (0, system.nodes[0]->balance (rai::test_genesis_key.pub)); + ASSERT_EQ (0, system.nodes[0]->balance (nano::test_genesis_key.pub)); } TEST (wallet, change) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key2; - auto block1 (system.nodes[0]->representative (rai::test_genesis_key.pub)); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key2; + auto block1 (system.nodes[0]->representative (nano::test_genesis_key.pub)); ASSERT_FALSE (block1.is_zero ()); - ASSERT_NE (nullptr, system.wallet (0)->change_action (rai::test_genesis_key.pub, key2.pub)); - auto block2 (system.nodes[0]->representative (rai::test_genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->change_action (nano::test_genesis_key.pub, key2.pub)); + auto block2 (system.nodes[0]->representative (nano::test_genesis_key.pub)); ASSERT_FALSE (block2.is_zero ()); ASSERT_NE (block1, block2); } TEST (wallet, partial_spend) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key2; - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, 500)); - ASSERT_EQ (std::numeric_limits::max () - 500, system.nodes[0]->balance (rai::test_genesis_key.pub)); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key2; + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, 500)); + ASSERT_EQ (std::numeric_limits::max () - 500, system.nodes[0]->balance (nano::test_genesis_key.pub)); } TEST (wallet, spend_no_previous) { - rai::system system (24000, 1); + nano::system system (24000, 1); { - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); auto transaction (system.nodes[0]->store.tx_begin ()); - rai::account_info info1; - ASSERT_FALSE (system.nodes[0]->store.account_get (transaction, rai::test_genesis_key.pub, info1)); + nano::account_info info1; + ASSERT_FALSE (system.nodes[0]->store.account_get (transaction, nano::test_genesis_key.pub, info1)); for (auto i (0); i < 50; ++i) { - rai::keypair key; + nano::keypair key; system.wallet (0)->insert_adhoc (key.prv); } } - rai::keypair key2; - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, 500)); - ASSERT_EQ (std::numeric_limits::max () - 500, system.nodes[0]->balance (rai::test_genesis_key.pub)); + nano::keypair key2; + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, 500)); + ASSERT_EQ (std::numeric_limits::max () - 500, system.nodes[0]->balance (nano::test_genesis_key.pub)); } TEST (wallet, find_none) { bool init; - rai::mdb_env env (init, rai::unique_path ()); + nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (init); - rai::uint256_union account (1000); + nano::uint256_union account (1000); ASSERT_EQ (wallet.end (), wallet.find (transaction, account)); } TEST (wallet, find_existing) { bool init; - rai::mdb_env env (init, rai::unique_path ()); + nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (init); - rai::keypair key1; + nano::keypair key1; ASSERT_FALSE (wallet.exists (transaction, key1.pub)); wallet.insert_adhoc (transaction, key1.prv); ASSERT_TRUE (wallet.exists (transaction, key1.pub)); @@ -282,27 +282,27 @@ TEST (wallet, find_existing) TEST (wallet, rekey) { bool init; - rai::mdb_env env (init, rai::unique_path ()); + nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (init); - rai::raw_key password; + nano::raw_key password; wallet.password.value (password); ASSERT_TRUE (password.data.is_zero ()); ASSERT_FALSE (init); - rai::keypair key1; + nano::keypair key1; wallet.insert_adhoc (transaction, key1.prv); - rai::raw_key prv1; + nano::raw_key prv1; wallet.fetch (transaction, key1.pub, prv1); ASSERT_EQ (key1.prv, prv1); ASSERT_FALSE (wallet.rekey (transaction, "1")); wallet.password.value (password); - rai::raw_key password1; + nano::raw_key password1; wallet.derive_key (password1, transaction, "1"); ASSERT_EQ (password1, password); - rai::raw_key prv2; + nano::raw_key prv2; wallet.fetch (transaction, key1.pub, prv2); ASSERT_EQ (key1.prv, prv2); *wallet.password.values[0] = 2; @@ -311,79 +311,79 @@ TEST (wallet, rekey) TEST (account, encode_zero) { - rai::uint256_union number0 (0); + nano::uint256_union number0 (0); std::string str0; number0.encode_account (str0); ASSERT_EQ (64, str0.size ()); - rai::uint256_union number1; + nano::uint256_union number1; ASSERT_FALSE (number1.decode_account (str0)); ASSERT_EQ (number0, number1); } TEST (account, encode_all) { - rai::uint256_union number0; + nano::uint256_union number0; number0.decode_hex ("ffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffffff"); std::string str0; number0.encode_account (str0); ASSERT_EQ (64, str0.size ()); - rai::uint256_union number1; + nano::uint256_union number1; ASSERT_FALSE (number1.decode_account (str0)); ASSERT_EQ (number0, number1); } TEST (account, encode_fail) { - rai::uint256_union number0 (0); + nano::uint256_union number0 (0); std::string str0; number0.encode_account (str0); str0[16] ^= 1; - rai::uint256_union number1; + nano::uint256_union number1; ASSERT_TRUE (number1.decode_account (str0)); } TEST (wallet, hash_password) { bool init; - rai::mdb_env env (init, rai::unique_path ()); + nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (init); - rai::raw_key hash1; + nano::raw_key hash1; wallet.derive_key (hash1, transaction, ""); - rai::raw_key hash2; + nano::raw_key hash2; wallet.derive_key (hash2, transaction, ""); ASSERT_EQ (hash1, hash2); - rai::raw_key hash3; + nano::raw_key hash3; wallet.derive_key (hash3, transaction, "a"); ASSERT_NE (hash1, hash3); } TEST (fan, reconstitute) { - rai::uint256_union value0 (0); - rai::fan fan (value0, 1024); + nano::uint256_union value0 (0); + nano::fan fan (value0, 1024); for (auto & i : fan.values) { ASSERT_NE (value0, *i); } - rai::raw_key value1; + nano::raw_key value1; fan.value (value1); ASSERT_EQ (value0, value1.data); } TEST (fan, change) { - rai::raw_key value0; + nano::raw_key value0; value0.data = 0; - rai::raw_key value1; + nano::raw_key value1; value1.data = 1; ASSERT_NE (value0, value1); - rai::fan fan (value0.data, 1024); + nano::fan fan (value0.data, 1024); ASSERT_EQ (1024, fan.values.size ()); - rai::raw_key value2; + nano::raw_key value2; fan.value (value2); ASSERT_EQ (value0, value2); fan.value_set (value1); @@ -394,30 +394,30 @@ TEST (fan, change) TEST (wallet, reopen_default_password) { bool init; - rai::mdb_env env (init, rai::unique_path ()); - rai::transaction transaction (env.tx_begin (true)); + nano::mdb_env env (init, nano::unique_path ()); + nano::transaction transaction (env.tx_begin (true)); ASSERT_FALSE (init); - rai::kdf kdf; + nano::kdf kdf; { - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (init); ASSERT_TRUE (wallet.valid_password (transaction)); } { bool init; - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (init); ASSERT_TRUE (wallet.valid_password (transaction)); } { - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (init); wallet.rekey (transaction, ""); ASSERT_TRUE (wallet.valid_password (transaction)); } { bool init; - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (init); ASSERT_FALSE (wallet.valid_password (transaction)); wallet.attempt_password (transaction, " "); @@ -430,16 +430,16 @@ TEST (wallet, reopen_default_password) TEST (wallet, representative) { auto error (false); - rai::mdb_env env (error, rai::unique_path ()); + nano::mdb_env env (error, nano::unique_path ()); ASSERT_FALSE (error); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet (error, kdf, transaction, rai::genesis_account, 1, "0"); + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet (error, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (error); ASSERT_FALSE (wallet.is_representative (transaction)); - ASSERT_EQ (rai::genesis_account, wallet.representative (transaction)); + ASSERT_EQ (nano::genesis_account, wallet.representative (transaction)); ASSERT_FALSE (wallet.is_representative (transaction)); - rai::keypair key; + nano::keypair key; wallet.representative_set (transaction, key.pub); ASSERT_FALSE (wallet.is_representative (transaction)); ASSERT_EQ (key.pub, wallet.representative (transaction)); @@ -451,18 +451,18 @@ TEST (wallet, representative) TEST (wallet, serialize_json_empty) { auto error (false); - rai::mdb_env env (error, rai::unique_path ()); + nano::mdb_env env (error, nano::unique_path ()); ASSERT_FALSE (error); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet1 (error, kdf, transaction, rai::genesis_account, 1, "0"); + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (error); std::string serialized; wallet1.serialize_json (transaction, serialized); - rai::wallet_store wallet2 (error, kdf, transaction, rai::genesis_account, 1, "1", serialized); + nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1", serialized); ASSERT_FALSE (error); - rai::raw_key password1; - rai::raw_key password2; + nano::raw_key password1; + nano::raw_key password2; wallet1.wallet_key (password1, transaction); wallet2.wallet_key (password2, transaction); ASSERT_EQ (password1, password2); @@ -476,20 +476,20 @@ TEST (wallet, serialize_json_empty) TEST (wallet, serialize_json_one) { auto error (false); - rai::mdb_env env (error, rai::unique_path ()); + nano::mdb_env env (error, nano::unique_path ()); ASSERT_FALSE (error); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet1 (error, kdf, transaction, rai::genesis_account, 1, "0"); + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (error); - rai::keypair key; + nano::keypair key; wallet1.insert_adhoc (transaction, key.prv); std::string serialized; wallet1.serialize_json (transaction, serialized); - rai::wallet_store wallet2 (error, kdf, transaction, rai::genesis_account, 1, "1", serialized); + nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1", serialized); ASSERT_FALSE (error); - rai::raw_key password1; - rai::raw_key password2; + nano::raw_key password1; + nano::raw_key password2; wallet1.wallet_key (password1, transaction); wallet2.wallet_key (password2, transaction); ASSERT_EQ (password1, password2); @@ -497,7 +497,7 @@ TEST (wallet, serialize_json_one) ASSERT_EQ (wallet1.check (transaction), wallet2.check (transaction)); ASSERT_EQ (wallet1.representative (transaction), wallet2.representative (transaction)); ASSERT_TRUE (wallet2.exists (transaction, key.pub)); - rai::raw_key prv; + nano::raw_key prv; wallet2.fetch (transaction, key.pub, prv); ASSERT_EQ (key.prv, prv); } @@ -505,24 +505,24 @@ TEST (wallet, serialize_json_one) TEST (wallet, serialize_json_password) { auto error (false); - rai::mdb_env env (error, rai::unique_path ()); + nano::mdb_env env (error, nano::unique_path ()); ASSERT_FALSE (error); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet1 (error, kdf, transaction, rai::genesis_account, 1, "0"); + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (error); - rai::keypair key; + nano::keypair key; wallet1.rekey (transaction, "password"); wallet1.insert_adhoc (transaction, key.prv); std::string serialized; wallet1.serialize_json (transaction, serialized); - rai::wallet_store wallet2 (error, kdf, transaction, rai::genesis_account, 1, "1", serialized); + nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1", serialized); ASSERT_FALSE (error); ASSERT_FALSE (wallet2.valid_password (transaction)); ASSERT_FALSE (wallet2.attempt_password (transaction, "password")); ASSERT_TRUE (wallet2.valid_password (transaction)); - rai::raw_key password1; - rai::raw_key password2; + nano::raw_key password1; + nano::raw_key password2; wallet1.wallet_key (password1, transaction); wallet2.wallet_key (password2, transaction); ASSERT_EQ (password1, password2); @@ -530,7 +530,7 @@ TEST (wallet, serialize_json_password) ASSERT_EQ (wallet1.check (transaction), wallet2.check (transaction)); ASSERT_EQ (wallet1.representative (transaction), wallet2.representative (transaction)); ASSERT_TRUE (wallet2.exists (transaction, key.pub)); - rai::raw_key prv; + nano::raw_key prv; wallet2.fetch (transaction, key.pub, prv); ASSERT_EQ (key.prv, prv); } @@ -538,21 +538,21 @@ TEST (wallet, serialize_json_password) TEST (wallet_store, move) { auto error (false); - rai::mdb_env env (error, rai::unique_path ()); + nano::mdb_env env (error, nano::unique_path ()); ASSERT_FALSE (error); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet1 (error, kdf, transaction, rai::genesis_account, 1, "0"); + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0"); ASSERT_FALSE (error); - rai::keypair key1; + nano::keypair key1; wallet1.insert_adhoc (transaction, key1.prv); - rai::wallet_store wallet2 (error, kdf, transaction, rai::genesis_account, 1, "1"); + nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1"); ASSERT_FALSE (error); - rai::keypair key2; + nano::keypair key2; wallet2.insert_adhoc (transaction, key2.prv); ASSERT_FALSE (wallet1.exists (transaction, key2.pub)); ASSERT_TRUE (wallet2.exists (transaction, key2.pub)); - std::vector keys; + std::vector keys; keys.push_back (key2.pub); ASSERT_FALSE (wallet1.move (transaction, wallet2, keys)); ASSERT_TRUE (wallet1.exists (transaction, key2.pub)); @@ -561,10 +561,10 @@ TEST (wallet_store, move) TEST (wallet_store, import) { - rai::system system (24000, 2); + nano::system system (24000, 2); auto wallet1 (system.wallet (0)); auto wallet2 (system.wallet (1)); - rai::keypair key1; + nano::keypair key1; wallet1->insert_adhoc (key1.prv); std::string json; wallet1->serialize (json); @@ -576,10 +576,10 @@ TEST (wallet_store, import) TEST (wallet_store, fail_import_bad_password) { - rai::system system (24000, 2); + nano::system system (24000, 2); auto wallet1 (system.wallet (0)); auto wallet2 (system.wallet (1)); - rai::keypair key1; + nano::keypair key1; wallet1->insert_adhoc (key1.prv); std::string json; wallet1->serialize (json); @@ -590,7 +590,7 @@ TEST (wallet_store, fail_import_bad_password) TEST (wallet_store, fail_import_corrupt) { - rai::system system (24000, 2); + nano::system system (24000, 2); auto wallet1 (system.wallet (1)); std::string json; auto error (wallet1->import (json, "1")); @@ -600,19 +600,19 @@ TEST (wallet_store, fail_import_corrupt) // Test work is precached when a key is inserted TEST (wallet, work) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto wallet (system.wallet (0)); - wallet->insert_adhoc (rai::test_genesis_key.prv); - rai::genesis genesis; + wallet->insert_adhoc (nano::test_genesis_key.prv); + nano::genesis genesis; auto done (false); system.deadline_set (10s); while (!done) { - rai::transaction transaction (system.nodes[0]->store.tx_begin ()); + nano::transaction transaction (system.nodes[0]->store.tx_begin ()); uint64_t work (0); - if (!wallet->store.work_get (transaction, rai::test_genesis_key.pub, work)) + if (!wallet->store.work_get (transaction, nano::test_genesis_key.pub, work)) { - done = !rai::work_validate (genesis.hash (), work); + done = !nano::work_validate (genesis.hash (), work); } ASSERT_NO_ERROR (system.poll ()); } @@ -620,21 +620,21 @@ TEST (wallet, work) TEST (wallet, work_generate) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto wallet (system.wallet (0)); - rai::uint128_t amount1 (system.nodes[0]->balance (rai::test_genesis_key.pub)); + nano::uint128_t amount1 (system.nodes[0]->balance (nano::test_genesis_key.pub)); uint64_t work1; - wallet->insert_adhoc (rai::test_genesis_key.prv); - rai::account account1; + wallet->insert_adhoc (nano::test_genesis_key.prv); + nano::account account1; { - rai::transaction transaction (system.nodes[0]->store.tx_begin ()); + nano::transaction transaction (system.nodes[0]->store.tx_begin ()); account1 = system.account (transaction, 0); } - rai::keypair key; - wallet->send_action (rai::test_genesis_key.pub, key.pub, 100); + nano::keypair key; + wallet->send_action (nano::test_genesis_key.pub, key.pub, 100); system.deadline_set (10s); auto transaction (system.nodes[0]->store.tx_begin ()); - while (system.nodes[0]->ledger.account_balance (transaction, rai::test_genesis_key.pub) == amount1) + while (system.nodes[0]->ledger.account_balance (transaction, nano::test_genesis_key.pub) == amount1) { ASSERT_NO_ERROR (system.poll ()); } @@ -644,13 +644,13 @@ TEST (wallet, work_generate) { ASSERT_NO_ERROR (system.poll ()); auto transaction (system.nodes[0]->store.tx_begin ()); - again = wallet->store.work_get (transaction, account1, work1) || rai::work_validate (system.nodes[0]->ledger.latest_root (transaction, account1), work1); + again = wallet->store.work_get (transaction, account1, work1) || nano::work_validate (system.nodes[0]->ledger.latest_root (transaction, account1), work1); } } TEST (wallet, insert_locked) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto wallet (system.wallet (0)); { auto transaction (wallet->wallets.tx_begin (true)); @@ -660,45 +660,45 @@ TEST (wallet, insert_locked) } auto transaction (wallet->wallets.tx_begin ()); ASSERT_FALSE (wallet->store.valid_password (transaction)); - ASSERT_TRUE (wallet->insert_adhoc (rai::keypair ().prv).is_zero ()); + ASSERT_TRUE (wallet->insert_adhoc (nano::keypair ().prv).is_zero ()); } TEST (wallet, version_1_upgrade) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto wallet (system.wallet (0)); wallet->enter_initial_password (); - rai::keypair key; + nano::keypair key; auto transaction (wallet->wallets.tx_begin (true)); ASSERT_TRUE (wallet->store.valid_password (transaction)); wallet->store.rekey (transaction, "1"); wallet->enter_password (transaction, ""); ASSERT_FALSE (wallet->store.valid_password (transaction)); - rai::raw_key password_l; - rai::wallet_value value (wallet->store.entry_get_raw (transaction, rai::wallet_store::wallet_key_special)); - rai::raw_key kdf; + nano::raw_key password_l; + nano::wallet_value value (wallet->store.entry_get_raw (transaction, nano::wallet_store::wallet_key_special)); + nano::raw_key kdf; kdf.data.clear (); password_l.decrypt (value.key, kdf, wallet->store.salt (transaction).owords[0]); - rai::uint256_union ciphertext; + nano::uint256_union ciphertext; ciphertext.encrypt (key.prv, password_l, wallet->store.salt (transaction).owords[0]); - wallet->store.entry_put_raw (transaction, key.pub, rai::wallet_value (ciphertext, 0)); + wallet->store.entry_put_raw (transaction, key.pub, nano::wallet_value (ciphertext, 0)); wallet->store.version_put (transaction, 1); wallet->enter_password (transaction, "1"); ASSERT_TRUE (wallet->store.valid_password (transaction)); ASSERT_EQ (wallet->store.version_current, wallet->store.version (transaction)); - rai::raw_key prv; + nano::raw_key prv; ASSERT_FALSE (wallet->store.fetch (transaction, key.pub, prv)); ASSERT_EQ (key.prv, prv); - value = wallet->store.entry_get_raw (transaction, rai::wallet_store::wallet_key_special); + value = wallet->store.entry_get_raw (transaction, nano::wallet_store::wallet_key_special); wallet->store.derive_key (kdf, transaction, ""); password_l.decrypt (value.key, kdf, wallet->store.salt (transaction).owords[0]); ciphertext.encrypt (key.prv, password_l, wallet->store.salt (transaction).owords[0]); - wallet->store.entry_put_raw (transaction, key.pub, rai::wallet_value (ciphertext, 0)); + wallet->store.entry_put_raw (transaction, key.pub, nano::wallet_value (ciphertext, 0)); wallet->store.version_put (transaction, 1); wallet->enter_password (transaction, "1"); ASSERT_TRUE (wallet->store.valid_password (transaction)); ASSERT_EQ (wallet->store.version_current, wallet->store.version (transaction)); - rai::raw_key prv2; + nano::raw_key prv2; ASSERT_FALSE (wallet->store.fetch (transaction, key.pub, prv2)); ASSERT_EQ (key.prv, prv2); } @@ -706,24 +706,24 @@ TEST (wallet, version_1_upgrade) TEST (wallet, deterministic_keys) { bool init; - rai::mdb_env env (init, rai::unique_path ()); + nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); - rai::raw_key key1; + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::raw_key key1; wallet.deterministic_key (key1, transaction, 0); - rai::raw_key key2; + nano::raw_key key2; wallet.deterministic_key (key2, transaction, 0); ASSERT_EQ (key1, key2); - rai::raw_key key3; + nano::raw_key key3; wallet.deterministic_key (key3, transaction, 1); ASSERT_NE (key1, key3); ASSERT_EQ (0, wallet.deterministic_index_get (transaction)); wallet.deterministic_index_set (transaction, 1); ASSERT_EQ (1, wallet.deterministic_index_get (transaction)); auto key4 (wallet.deterministic_insert (transaction)); - rai::raw_key key5; + nano::raw_key key5; ASSERT_FALSE (wallet.fetch (transaction, key4, key5)); ASSERT_EQ (key3, key5); ASSERT_EQ (2, wallet.deterministic_index_get (transaction)); @@ -734,11 +734,11 @@ TEST (wallet, deterministic_keys) auto key8 (wallet.deterministic_insert (transaction)); ASSERT_EQ (key4, key8); auto key6 (wallet.deterministic_insert (transaction)); - rai::raw_key key7; + nano::raw_key key7; ASSERT_FALSE (wallet.fetch (transaction, key6, key7)); ASSERT_NE (key5, key7); ASSERT_EQ (3, wallet.deterministic_index_get (transaction)); - rai::keypair key9; + nano::keypair key9; ASSERT_EQ (key9.pub, wallet.insert_adhoc (transaction, key9.prv)); ASSERT_TRUE (wallet.exists (transaction, key9.pub)); wallet.deterministic_clear (transaction); @@ -752,30 +752,30 @@ TEST (wallet, deterministic_keys) TEST (wallet, reseed) { bool init; - rai::mdb_env env (init, rai::unique_path ()); + nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); - rai::transaction transaction (env.tx_begin (true)); - rai::kdf kdf; - rai::wallet_store wallet (init, kdf, transaction, rai::genesis_account, 1, "0"); - rai::raw_key seed1; + nano::transaction transaction (env.tx_begin (true)); + nano::kdf kdf; + nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::raw_key seed1; seed1.data = 1; - rai::raw_key seed2; + nano::raw_key seed2; seed2.data = 2; wallet.seed_set (transaction, seed1); - rai::raw_key seed3; + nano::raw_key seed3; wallet.seed (seed3, transaction); ASSERT_EQ (seed1, seed3); auto key1 (wallet.deterministic_insert (transaction)); ASSERT_EQ (1, wallet.deterministic_index_get (transaction)); wallet.seed_set (transaction, seed2); ASSERT_EQ (0, wallet.deterministic_index_get (transaction)); - rai::raw_key seed4; + nano::raw_key seed4; wallet.seed (seed4, transaction); ASSERT_EQ (seed2, seed4); auto key2 (wallet.deterministic_insert (transaction)); ASSERT_NE (key1, key2); wallet.seed_set (transaction, seed1); - rai::raw_key seed5; + nano::raw_key seed5; wallet.seed (seed5, transaction); ASSERT_EQ (seed1, seed5); auto key3 (wallet.deterministic_insert (transaction)); @@ -784,7 +784,7 @@ TEST (wallet, reseed) TEST (wallet, insert_deterministic_locked) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto wallet (system.wallet (0)); auto transaction (wallet->wallets.tx_begin (true)); wallet->store.rekey (transaction, "1"); @@ -796,91 +796,91 @@ TEST (wallet, insert_deterministic_locked) TEST (wallet, version_2_upgrade) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto wallet (system.wallet (0)); auto transaction (wallet->wallets.tx_begin (true)); wallet->store.rekey (transaction, "1"); ASSERT_TRUE (wallet->store.attempt_password (transaction, "")); - wallet->store.erase (transaction, rai::wallet_store::deterministic_index_special); - wallet->store.erase (transaction, rai::wallet_store::seed_special); + wallet->store.erase (transaction, nano::wallet_store::deterministic_index_special); + wallet->store.erase (transaction, nano::wallet_store::seed_special); wallet->store.version_put (transaction, 2); ASSERT_EQ (2, wallet->store.version (transaction)); - ASSERT_FALSE (wallet->store.exists (transaction, rai::wallet_store::deterministic_index_special)); - ASSERT_FALSE (wallet->store.exists (transaction, rai::wallet_store::seed_special)); + ASSERT_FALSE (wallet->store.exists (transaction, nano::wallet_store::deterministic_index_special)); + ASSERT_FALSE (wallet->store.exists (transaction, nano::wallet_store::seed_special)); wallet->store.attempt_password (transaction, "1"); ASSERT_EQ (wallet->store.version_current, wallet->store.version (transaction)); - ASSERT_TRUE (wallet->store.exists (transaction, rai::wallet_store::deterministic_index_special)); - ASSERT_TRUE (wallet->store.exists (transaction, rai::wallet_store::seed_special)); + ASSERT_TRUE (wallet->store.exists (transaction, nano::wallet_store::deterministic_index_special)); + ASSERT_TRUE (wallet->store.exists (transaction, nano::wallet_store::seed_special)); ASSERT_FALSE (wallet->deterministic_insert (transaction).is_zero ()); } TEST (wallet, version_3_upgrade) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto wallet (system.wallet (0)); auto transaction (wallet->wallets.tx_begin (true)); wallet->store.rekey (transaction, "1"); wallet->enter_password (transaction, "1"); ASSERT_TRUE (wallet->store.valid_password (transaction)); ASSERT_EQ (wallet->store.version_current, wallet->store.version (transaction)); - rai::keypair key; - rai::raw_key seed; - rai::uint256_union seed_ciphertext; - rai::random_pool.GenerateBlock (seed.data.bytes.data (), seed.data.bytes.size ()); - rai::raw_key password_l; - rai::wallet_value value (wallet->store.entry_get_raw (transaction, rai::wallet_store::wallet_key_special)); - rai::raw_key kdf; + nano::keypair key; + nano::raw_key seed; + nano::uint256_union seed_ciphertext; + nano::random_pool.GenerateBlock (seed.data.bytes.data (), seed.data.bytes.size ()); + nano::raw_key password_l; + nano::wallet_value value (wallet->store.entry_get_raw (transaction, nano::wallet_store::wallet_key_special)); + nano::raw_key kdf; wallet->store.derive_key (kdf, transaction, "1"); password_l.decrypt (value.key, kdf, wallet->store.salt (transaction).owords[0]); - rai::uint256_union ciphertext; + nano::uint256_union ciphertext; ciphertext.encrypt (key.prv, password_l, wallet->store.salt (transaction).owords[0]); - wallet->store.entry_put_raw (transaction, key.pub, rai::wallet_value (ciphertext, 0)); + wallet->store.entry_put_raw (transaction, key.pub, nano::wallet_value (ciphertext, 0)); seed_ciphertext.encrypt (seed, password_l, wallet->store.salt (transaction).owords[0]); - wallet->store.entry_put_raw (transaction, rai::wallet_store::seed_special, rai::wallet_value (seed_ciphertext, 0)); + wallet->store.entry_put_raw (transaction, nano::wallet_store::seed_special, nano::wallet_value (seed_ciphertext, 0)); wallet->store.version_put (transaction, 3); wallet->enter_password (transaction, "1"); ASSERT_TRUE (wallet->store.valid_password (transaction)); ASSERT_EQ (wallet->store.version_current, wallet->store.version (transaction)); - rai::raw_key prv; + nano::raw_key prv; ASSERT_FALSE (wallet->store.fetch (transaction, key.pub, prv)); ASSERT_EQ (key.prv, prv); - rai::raw_key seed_compare; + nano::raw_key seed_compare; wallet->store.seed (seed_compare, transaction); ASSERT_EQ (seed, seed_compare); - ASSERT_NE (seed_ciphertext, wallet->store.entry_get_raw (transaction, rai::wallet_store::seed_special).key); + ASSERT_NE (seed_ciphertext, wallet->store.entry_get_raw (transaction, nano::wallet_store::seed_special).key); } TEST (wallet, no_work) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv, false); - rai::keypair key2; - auto block (system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, std::numeric_limits::max (), false)); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv, false); + nano::keypair key2; + auto block (system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, std::numeric_limits::max (), false)); ASSERT_NE (nullptr, block); ASSERT_NE (0, block->block_work ()); - ASSERT_FALSE (rai::work_validate (block->root (), block->block_work ())); + ASSERT_FALSE (nano::work_validate (block->root (), block->block_work ())); auto transaction (system.nodes[0]->store.tx_begin ()); uint64_t cached_work (0); - system.wallet (0)->store.work_get (transaction, rai::test_genesis_key.pub, cached_work); + system.wallet (0)->store.work_get (transaction, nano::test_genesis_key.pub, cached_work); ASSERT_EQ (0, cached_work); } TEST (wallet, send_race) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key2; + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key2; for (auto i (1); i < 60; ++i) { - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, rai::Gxrb_ratio)); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio * i, system.nodes[0]->balance (rai::test_genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::test_genesis_key.pub, key2.pub, nano::Gxrb_ratio)); + ASSERT_EQ (nano::genesis_amount - nano::Gxrb_ratio * i, system.nodes[0]->balance (nano::test_genesis_key.pub)); } } TEST (wallet, password_race) { - rai::system system (24000, 1); - rai::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); + nano::system system (24000, 1); + nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); auto wallet = system.wallet (0); system.nodes[0]->background ([&wallet]() { for (int i = 0; i < 100; i++) @@ -906,10 +906,10 @@ TEST (wallet, password_race) TEST (wallet, password_race_corrupt_seed) { - rai::system system (24000, 1); - rai::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); + nano::system system (24000, 1); + nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); auto wallet = system.wallet (0); - rai::raw_key seed; + nano::raw_key seed; { auto transaction (wallet->wallets.tx_begin (true)); ASSERT_FALSE (wallet->store.rekey (transaction, "4567")); @@ -946,19 +946,19 @@ TEST (wallet, password_race_corrupt_seed) auto transaction (wallet->wallets.tx_begin (true)); if (!wallet->store.attempt_password (transaction, "1234")) { - rai::raw_key seed_now; + nano::raw_key seed_now; wallet->store.seed (seed_now, transaction); ASSERT_TRUE (seed_now == seed); } else if (!wallet->store.attempt_password (transaction, "0000")) { - rai::raw_key seed_now; + nano::raw_key seed_now; wallet->store.seed (seed_now, transaction); ASSERT_TRUE (seed_now == seed); } else if (!wallet->store.attempt_password (transaction, "4567")) { - rai::raw_key seed_now; + nano::raw_key seed_now; wallet->store.seed (seed_now, transaction); ASSERT_TRUE (seed_now == seed); } diff --git a/rai/core_test/wallets.cpp b/nano/core_test/wallets.cpp similarity index 73% rename from rai/core_test/wallets.cpp rename to nano/core_test/wallets.cpp index 431140d3..326975d8 100644 --- a/rai/core_test/wallets.cpp +++ b/nano/core_test/wallets.cpp @@ -1,18 +1,18 @@ #include -#include -#include +#include +#include using namespace std::chrono_literals; TEST (wallets, open_create) { - rai::system system (24000, 1); + nano::system system (24000, 1); bool error (false); - rai::wallets wallets (error, *system.nodes[0]); + nano::wallets wallets (error, *system.nodes[0]); ASSERT_FALSE (error); ASSERT_EQ (1, wallets.items.size ()); // it starts out with a default wallet - rai::uint256_union id; + nano::uint256_union id; ASSERT_EQ (nullptr, wallets.open (id)); auto wallet (wallets.create (id)); ASSERT_NE (nullptr, wallet); @@ -21,17 +21,17 @@ TEST (wallets, open_create) TEST (wallets, open_existing) { - rai::system system (24000, 1); - rai::uint256_union id; + nano::system system (24000, 1); + nano::uint256_union id; { bool error (false); - rai::wallets wallets (error, *system.nodes[0]); + nano::wallets wallets (error, *system.nodes[0]); ASSERT_FALSE (error); ASSERT_EQ (1, wallets.items.size ()); auto wallet (wallets.create (id)); ASSERT_NE (nullptr, wallet); ASSERT_EQ (wallet, wallets.open (id)); - rai::raw_key password; + nano::raw_key password; password.data.clear (); system.deadline_set (10s); while (password.data == 0) @@ -42,7 +42,7 @@ TEST (wallets, open_existing) } { bool error (false); - rai::wallets wallets (error, *system.nodes[0]); + nano::wallets wallets (error, *system.nodes[0]); ASSERT_FALSE (error); ASSERT_EQ (2, wallets.items.size ()); ASSERT_NE (nullptr, wallets.open (id)); @@ -51,11 +51,11 @@ TEST (wallets, open_existing) TEST (wallets, remove) { - rai::system system (24000, 1); - rai::uint256_union one (1); + nano::system system (24000, 1); + nano::uint256_union one (1); { bool error (false); - rai::wallets wallets (error, *system.nodes[0]); + nano::wallets wallets (error, *system.nodes[0]); ASSERT_FALSE (error); ASSERT_EQ (1, wallets.items.size ()); auto wallet (wallets.create (one)); @@ -66,7 +66,7 @@ TEST (wallets, remove) } { bool error (false); - rai::wallets wallets (error, *system.nodes[0]); + nano::wallets wallets (error, *system.nodes[0]); ASSERT_FALSE (error); ASSERT_EQ (1, wallets.items.size ()); } @@ -75,22 +75,22 @@ TEST (wallets, remove) // Keeps breaking whenever we add new DBs TEST (wallets, DISABLED_wallet_create_max) { - rai::system system (24000, 1); + nano::system system (24000, 1); bool error (false); - rai::wallets wallets (error, *system.nodes[0]); + nano::wallets wallets (error, *system.nodes[0]); const int nonWalletDbs = 19; for (int i = 0; i < system.nodes[0]->config.lmdb_max_dbs - nonWalletDbs; i++) { - rai::keypair key; + nano::keypair key; auto wallet = wallets.create (key.pub); auto existing = wallets.items.find (key.pub); ASSERT_TRUE (existing != wallets.items.end ()); - rai::raw_key seed; + nano::raw_key seed; seed.data = 0; auto transaction (system.nodes[0]->store.tx_begin (true)); existing->second->store.seed_set (transaction, seed); } - rai::keypair key; + nano::keypair key; wallets.create (key.pub); auto existing = wallets.items.find (key.pub); ASSERT_TRUE (existing == wallets.items.end ()); diff --git a/rai/core_test/work_pool.cpp b/nano/core_test/work_pool.cpp similarity index 51% rename from rai/core_test/work_pool.cpp rename to nano/core_test/work_pool.cpp index dd9bbb46..5f2f6328 100644 --- a/rai/core_test/work_pool.cpp +++ b/nano/core_test/work_pool.cpp @@ -1,38 +1,38 @@ #include -#include -#include +#include +#include TEST (work, one) { - rai::work_pool pool (std::numeric_limits::max (), nullptr); - rai::change_block block (1, 1, rai::keypair ().prv, 3, 4); + nano::work_pool pool (std::numeric_limits::max (), nullptr); + nano::change_block block (1, 1, nano::keypair ().prv, 3, 4); block.block_work_set (pool.generate (block.root ())); uint64_t difficulty; - ASSERT_FALSE (rai::work_validate (block, &difficulty)); - ASSERT_LT (rai::work_pool::publish_threshold, difficulty); + ASSERT_FALSE (nano::work_validate (block, &difficulty)); + ASSERT_LT (nano::work_pool::publish_threshold, difficulty); } TEST (work, validate) { - rai::work_pool pool (std::numeric_limits::max (), nullptr); - rai::send_block send_block (1, 1, 2, rai::keypair ().prv, 4, 6); + nano::work_pool pool (std::numeric_limits::max (), nullptr); + nano::send_block send_block (1, 1, 2, nano::keypair ().prv, 4, 6); uint64_t difficulty; - ASSERT_TRUE (rai::work_validate (send_block, &difficulty)); - ASSERT_LT (difficulty, rai::work_pool::publish_threshold); + ASSERT_TRUE (nano::work_validate (send_block, &difficulty)); + ASSERT_LT (difficulty, nano::work_pool::publish_threshold); send_block.block_work_set (pool.generate (send_block.root ())); - ASSERT_FALSE (rai::work_validate (send_block, &difficulty)); - ASSERT_LT (rai::work_pool::publish_threshold, difficulty); + ASSERT_FALSE (nano::work_validate (send_block, &difficulty)); + ASSERT_LT (nano::work_pool::publish_threshold, difficulty); } TEST (work, cancel) { - rai::work_pool pool (std::numeric_limits::max (), nullptr); + nano::work_pool pool (std::numeric_limits::max (), nullptr); auto iterations (0); auto done (false); while (!done) { - rai::uint256_union key (1); + nano::uint256_union key (1); pool.generate (key, [&done](boost::optional work_a) { done = !work_a; }); @@ -44,13 +44,13 @@ TEST (work, cancel) TEST (work, cancel_many) { - rai::work_pool pool (std::numeric_limits::max (), nullptr); - rai::uint256_union key1 (1); - rai::uint256_union key2 (2); - rai::uint256_union key3 (1); - rai::uint256_union key4 (1); - rai::uint256_union key5 (3); - rai::uint256_union key6 (1); + nano::work_pool pool (std::numeric_limits::max (), nullptr); + nano::uint256_union key1 (1); + nano::uint256_union key2 (2); + nano::uint256_union key3 (1); + nano::uint256_union key4 (1); + nano::uint256_union key5 (3); + nano::uint256_union key6 (1); pool.generate (key1, [](boost::optional) {}); pool.generate (key2, [](boost::optional) {}); pool.generate (key3, [](boost::optional) {}); @@ -62,35 +62,35 @@ TEST (work, cancel_many) TEST (work, DISABLED_opencl) { - rai::logging logging; - logging.init (rai::unique_path ()); - auto opencl (rai::opencl_work::create (true, { 0, 1, 1024 * 1024 }, logging)); + nano::logging logging; + logging.init (nano::unique_path ()); + auto opencl (nano::opencl_work::create (true, { 0, 1, 1024 * 1024 }, logging)); if (opencl != nullptr) { - rai::work_pool pool (std::numeric_limits::max (), opencl ? [&opencl](rai::uint256_union const & root_a) { + nano::work_pool pool (std::numeric_limits::max (), opencl ? [&opencl](nano::uint256_union const & root_a) { return opencl->generate_work (root_a); } - : std::function (rai::uint256_union const &)> (nullptr)); + : std::function (nano::uint256_union const &)> (nullptr)); ASSERT_NE (nullptr, pool.opencl); - rai::uint256_union root; + nano::uint256_union root; for (auto i (0); i < 1; ++i) { - rai::random_pool.GenerateBlock (root.bytes.data (), root.bytes.size ()); + nano::random_pool.GenerateBlock (root.bytes.data (), root.bytes.size ()); auto result (pool.generate (root)); - ASSERT_FALSE (rai::work_validate (root, result)); + ASSERT_FALSE (nano::work_validate (root, result)); } } } TEST (work, opencl_config) { - rai::opencl_config config1; + nano::opencl_config config1; config1.platform = 1; config1.device = 2; config1.threads = 3; boost::property_tree::ptree tree; config1.serialize_json (tree); - rai::opencl_config config2; + nano::opencl_config config2; ASSERT_FALSE (config2.deserialize_json (tree)); ASSERT_EQ (1, config2.platform); ASSERT_EQ (2, config2.device); @@ -99,8 +99,8 @@ TEST (work, opencl_config) TEST (work, difficulty) { - rai::work_pool pool (std::numeric_limits::max (), nullptr); - rai::uint256_union root (1); + nano::work_pool pool (std::numeric_limits::max (), nullptr); + nano::uint256_union root (1); uint64_t difficulty1 (0xff00000000000000); uint64_t difficulty2 (0xfff0000000000000); uint64_t difficulty3 (0xffff000000000000); @@ -109,7 +109,7 @@ TEST (work, difficulty) do { work1 = pool.generate (root, difficulty1); - rai::work_validate (root, work1, &nonce1); + nano::work_validate (root, work1, &nonce1); } while (nonce1 > difficulty2); ASSERT_GT (nonce1, difficulty1); uint64_t work2 (0); @@ -117,7 +117,7 @@ TEST (work, difficulty) do { work2 = pool.generate (root, difficulty2); - rai::work_validate (root, work2, &nonce2); + nano::work_validate (root, work2, &nonce2); } while (nonce2 > difficulty3); ASSERT_GT (nonce2, difficulty2); } diff --git a/rai/lib/CMakeLists.txt b/nano/lib/CMakeLists.txt similarity index 86% rename from rai/lib/CMakeLists.txt rename to nano/lib/CMakeLists.txt index 4cce6170..bbaa8788 100644 --- a/rai/lib/CMakeLists.txt +++ b/nano/lib/CMakeLists.txt @@ -10,7 +10,7 @@ else () error ("Unknown platform: ${CMAKE_SYSTEM_NAME}") endif () -add_library (rai_lib +add_library (nano_lib ${platform_sources} errors.hpp errors.cpp @@ -29,19 +29,19 @@ add_library (rai_lib work.hpp work.cpp) -target_link_libraries (rai_lib +target_link_libraries (nano_lib xxhash blake2 ${CRYPTOPP_LIBRARY} Boost::boost) -target_compile_definitions(rai_lib +target_compile_definitions(nano_lib PUBLIC -DACTIVE_NETWORK=${ACTIVE_NETWORK} ) -if (RAIBLOCKS_GUI AND NOT APPLE) - install(TARGETS rai_lib +if ((NANO_GUI OR RAIBLOCKS_GUI) AND NOT APPLE) + install(TARGETS nano_lib RUNTIME DESTINATION bin LIBRARY DESTINATION lib ARCHIVE DESTINATION lib diff --git a/rai/lib/blockbuilders.cpp b/nano/lib/blockbuilders.cpp similarity index 66% rename from rai/lib/blockbuilders.cpp rename to nano/lib/blockbuilders.cpp index f0ef6ce1..c3b523fb 100644 --- a/rai/lib/blockbuilders.cpp +++ b/nano/lib/blockbuilders.cpp @@ -1,6 +1,6 @@ #include -#include -#include +#include +#include #include namespace @@ -8,7 +8,7 @@ namespace template void previous_hex_impl (std::string const & previous_hex, std::error_code & ec, BLOCKTYPE & block) { - rai::block_hash previous; + nano::block_hash previous; if (!previous.decode_hex (previous_hex)) { block->hashables.previous = previous; @@ -22,7 +22,7 @@ void previous_hex_impl (std::string const & previous_hex, std::error_code & ec, template void account_hex_impl (std::string const & account_hex, std::error_code & ec, BLOCKTYPE & block) { - rai::account account; + nano::account account; if (!account.decode_hex (account_hex)) { block->hashables.account = account; @@ -36,7 +36,7 @@ void account_hex_impl (std::string const & account_hex, std::error_code & ec, BL template void account_address_impl (std::string const & address, std::error_code & ec, BLOCKTYPE & block) { - rai::account account; + nano::account account; if (!account.decode_account (address)) { block->hashables.account = account; @@ -50,7 +50,7 @@ void account_address_impl (std::string const & address, std::error_code & ec, BL template void representative_hex_impl (std::string const & account_hex, std::error_code & ec, BLOCKTYPE & block) { - rai::account account; + nano::account account; if (!account.decode_hex (account_hex)) { block->hashables.representative = account; @@ -64,7 +64,7 @@ void representative_hex_impl (std::string const & account_hex, std::error_code & template void representative_address_impl (std::string const & address, std::error_code & ec, BLOCKTYPE & block) { - rai::account account; + nano::account account; if (!account.decode_account (address)) { block->hashables.representative = account; @@ -78,7 +78,7 @@ void representative_address_impl (std::string const & address, std::error_code & template void destination_hex_impl (std::string const & account_hex, std::error_code & ec, BLOCKTYPE & block) { - rai::account account; + nano::account account; if (!account.decode_hex (account_hex)) { block->hashables.destination = account; @@ -92,7 +92,7 @@ void destination_hex_impl (std::string const & account_hex, std::error_code & ec template void destination_address_impl (std::string const & address, std::error_code & ec, BLOCKTYPE & block) { - rai::account account; + nano::account account; if (!account.decode_account (address)) { block->hashables.destination = account; @@ -106,7 +106,7 @@ void destination_address_impl (std::string const & address, std::error_code & ec template void source_hex_impl (std::string const & source_hex, std::error_code & ec, BLOCKTYPE & block) { - rai::block_hash source; + nano::block_hash source; if (!source.decode_hex (source_hex)) { block->hashables.source = source; @@ -120,7 +120,7 @@ void source_hex_impl (std::string const & source_hex, std::error_code & ec, BLOC template void balance_dec_impl (std::string const & balance_decimal, std::error_code & ec, BLOCKTYPE & block) { - rai::amount balance; + nano::amount balance; if (!balance.decode_dec (balance_decimal)) { block->hashables.balance = balance; @@ -134,7 +134,7 @@ void balance_dec_impl (std::string const & balance_decimal, std::error_code & ec template void balance_hex_impl (std::string const & balance_hex, std::error_code & ec, BLOCKTYPE & block) { - rai::amount balance; + nano::amount balance; if (!balance.decode_hex (balance_hex)) { block->hashables.balance = balance; @@ -147,13 +147,13 @@ void balance_hex_impl (std::string const & balance_hex, std::error_code & ec, BL /* The cost of looking up the error_code map is only taken if field-presence checks fail */ std::unordered_map ec_map = { - { static_cast (rai::build_flags::account_present), nano::error_common::missing_account }, - { static_cast (rai::build_flags::balance_present), nano::error_common::missing_balance }, - { static_cast (rai::build_flags::link_present), nano::error_common::missing_link }, - { static_cast (rai::build_flags::previous_present), nano::error_common::missing_previous }, - { static_cast (rai::build_flags::representative_present), nano::error_common::missing_representative }, - { static_cast (rai::build_flags::signature_present), nano::error_common::missing_signature }, - { static_cast (rai::build_flags::work_present), nano::error_common::missing_work } + { static_cast (nano::build_flags::account_present), nano::error_common::missing_account }, + { static_cast (nano::build_flags::balance_present), nano::error_common::missing_balance }, + { static_cast (nano::build_flags::link_present), nano::error_common::missing_link }, + { static_cast (nano::build_flags::previous_present), nano::error_common::missing_previous }, + { static_cast (nano::build_flags::representative_present), nano::error_common::missing_representative }, + { static_cast (nano::build_flags::signature_present), nano::error_common::missing_signature }, + { static_cast (nano::build_flags::work_present), nano::error_common::missing_work } }; /** Find first set bit as a mask, e.g. 10101000 => 0x08. Returns -1 if no bit is set. */ @@ -192,18 +192,18 @@ std::error_code check_fields_set (uint8_t block_all_flags, uint8_t build_state) } } // anonymous namespace -rai::state_block_builder::state_block_builder () +nano::state_block_builder::state_block_builder () { make_block (); } -rai::state_block_builder & rai::state_block_builder::make_block () +nano::state_block_builder & nano::state_block_builder::make_block () { construct_block (); return *this; } -void rai::state_block_builder::validate () +void nano::state_block_builder::validate () { if (!ec) { @@ -211,7 +211,7 @@ void rai::state_block_builder::validate () } } -rai::state_block_builder & rai::state_block_builder::zero () +nano::state_block_builder & nano::state_block_builder::zero () { block->work = uint64_t (0); block->signature.clear (); @@ -224,93 +224,93 @@ rai::state_block_builder & rai::state_block_builder::zero () return *this; } -rai::state_block_builder & rai::state_block_builder::account (rai::account account) +nano::state_block_builder & nano::state_block_builder::account (nano::account account) { block->hashables.account = account; build_state |= build_flags::account_present; return *this; } -rai::state_block_builder & rai::state_block_builder::account_hex (std::string account_hex) +nano::state_block_builder & nano::state_block_builder::account_hex (std::string account_hex) { account_hex_impl (account_hex, ec, block); build_state |= build_flags::account_present; return *this; } -rai::state_block_builder & rai::state_block_builder::account_address (std::string address) +nano::state_block_builder & nano::state_block_builder::account_address (std::string address) { account_address_impl (address, ec, block); build_state |= build_flags::account_present; return *this; } -rai::state_block_builder & rai::state_block_builder::representative (rai::account account) +nano::state_block_builder & nano::state_block_builder::representative (nano::account account) { block->hashables.representative = account; build_state |= build_flags::representative_present; return *this; } -rai::state_block_builder & rai::state_block_builder::representative_hex (std::string account_hex) +nano::state_block_builder & nano::state_block_builder::representative_hex (std::string account_hex) { representative_hex_impl (account_hex, ec, block); build_state |= build_flags::representative_present; return *this; } -rai::state_block_builder & rai::state_block_builder::representative_address (std::string address) +nano::state_block_builder & nano::state_block_builder::representative_address (std::string address) { representative_address_impl (address, ec, block); build_state |= build_flags::representative_present; return *this; } -rai::state_block_builder & rai::state_block_builder::previous (rai::block_hash previous) +nano::state_block_builder & nano::state_block_builder::previous (nano::block_hash previous) { block->hashables.previous = previous; build_state |= build_flags::previous_present; return *this; } -rai::state_block_builder & rai::state_block_builder::previous_hex (std::string previous_hex) +nano::state_block_builder & nano::state_block_builder::previous_hex (std::string previous_hex) { previous_hex_impl (previous_hex, ec, block); build_state |= build_flags::previous_present; return *this; } -rai::state_block_builder & rai::state_block_builder::balance (rai::amount balance) +nano::state_block_builder & nano::state_block_builder::balance (nano::amount balance) { block->hashables.balance = balance; build_state |= build_flags::balance_present; return *this; } -rai::state_block_builder & rai::state_block_builder::balance_dec (std::string balance_decimal) +nano::state_block_builder & nano::state_block_builder::balance_dec (std::string balance_decimal) { balance_dec_impl (balance_decimal, ec, block); build_state |= build_flags::balance_present; return *this; } -rai::state_block_builder & rai::state_block_builder::balance_hex (std::string balance_hex) +nano::state_block_builder & nano::state_block_builder::balance_hex (std::string balance_hex) { balance_hex_impl (balance_hex, ec, block); build_state |= build_flags::balance_present; return *this; } -rai::state_block_builder & rai::state_block_builder::link (rai::uint256_union link) +nano::state_block_builder & nano::state_block_builder::link (nano::uint256_union link) { block->hashables.link = link; build_state |= build_flags::link_present; return *this; } -rai::state_block_builder & rai::state_block_builder::link_hex (std::string link_hex) +nano::state_block_builder & nano::state_block_builder::link_hex (std::string link_hex) { - rai::uint256_union link; + nano::uint256_union link; if (!link.decode_hex (link_hex)) { block->hashables.link = link; @@ -323,9 +323,9 @@ rai::state_block_builder & rai::state_block_builder::link_hex (std::string link_ return *this; } -rai::state_block_builder & rai::state_block_builder::link_address (std::string link_address) +nano::state_block_builder & nano::state_block_builder::link_address (std::string link_address) { - rai::account link; + nano::account link; if (!link.decode_account (link_address)) { block->hashables.link = link; @@ -338,18 +338,18 @@ rai::state_block_builder & rai::state_block_builder::link_address (std::string l return *this; } -rai::open_block_builder::open_block_builder () +nano::open_block_builder::open_block_builder () { make_block (); } -rai::open_block_builder & rai::open_block_builder::make_block () +nano::open_block_builder & nano::open_block_builder::make_block () { construct_block (); return *this; } -void rai::open_block_builder::validate () +void nano::open_block_builder::validate () { if (!ec) { @@ -357,7 +357,7 @@ void rai::open_block_builder::validate () } } -rai::open_block_builder & rai::open_block_builder::zero () +nano::open_block_builder & nano::open_block_builder::zero () { block->work = uint64_t (0); block->signature.clear (); @@ -368,74 +368,74 @@ rai::open_block_builder & rai::open_block_builder::zero () return *this; } -rai::open_block_builder & rai::open_block_builder::account (rai::account account) +nano::open_block_builder & nano::open_block_builder::account (nano::account account) { block->hashables.account = account; build_state |= build_flags::account_present; return *this; } -rai::open_block_builder & rai::open_block_builder::account_hex (std::string account_hex) +nano::open_block_builder & nano::open_block_builder::account_hex (std::string account_hex) { account_hex_impl (account_hex, ec, block); build_state |= build_flags::account_present; return *this; } -rai::open_block_builder & rai::open_block_builder::account_address (std::string address) +nano::open_block_builder & nano::open_block_builder::account_address (std::string address) { account_address_impl (address, ec, block); build_state |= build_flags::account_present; return *this; } -rai::open_block_builder & rai::open_block_builder::representative (rai::account account) +nano::open_block_builder & nano::open_block_builder::representative (nano::account account) { block->hashables.representative = account; build_state |= build_flags::representative_present; return *this; } -rai::open_block_builder & rai::open_block_builder::representative_hex (std::string account_hex) +nano::open_block_builder & nano::open_block_builder::representative_hex (std::string account_hex) { representative_hex_impl (account_hex, ec, block); build_state |= build_flags::representative_present; return *this; } -rai::open_block_builder & rai::open_block_builder::representative_address (std::string address) +nano::open_block_builder & nano::open_block_builder::representative_address (std::string address) { representative_address_impl (address, ec, block); build_state |= build_flags::representative_present; return *this; } -rai::open_block_builder & rai::open_block_builder::source (rai::block_hash source) +nano::open_block_builder & nano::open_block_builder::source (nano::block_hash source) { block->hashables.source = source; build_state |= build_flags::link_present; return *this; } -rai::open_block_builder & rai::open_block_builder::source_hex (std::string source_hex) +nano::open_block_builder & nano::open_block_builder::source_hex (std::string source_hex) { source_hex_impl (source_hex, ec, block); build_state |= build_flags::link_present; return *this; } -rai::change_block_builder::change_block_builder () +nano::change_block_builder::change_block_builder () { make_block (); } -rai::change_block_builder & rai::change_block_builder::make_block () +nano::change_block_builder & nano::change_block_builder::make_block () { construct_block (); return *this; } -void rai::change_block_builder::validate () +void nano::change_block_builder::validate () { if (!ec) { @@ -443,7 +443,7 @@ void rai::change_block_builder::validate () } } -rai::change_block_builder & rai::change_block_builder::zero () +nano::change_block_builder & nano::change_block_builder::zero () { block->work = uint64_t (0); block->signature.clear (); @@ -453,53 +453,53 @@ rai::change_block_builder & rai::change_block_builder::zero () return *this; } -rai::change_block_builder & rai::change_block_builder::representative (rai::account account) +nano::change_block_builder & nano::change_block_builder::representative (nano::account account) { block->hashables.representative = account; build_state |= build_flags::representative_present; return *this; } -rai::change_block_builder & rai::change_block_builder::representative_hex (std::string account_hex) +nano::change_block_builder & nano::change_block_builder::representative_hex (std::string account_hex) { representative_hex_impl (account_hex, ec, block); build_state |= build_flags::representative_present; return *this; } -rai::change_block_builder & rai::change_block_builder::representative_address (std::string address) +nano::change_block_builder & nano::change_block_builder::representative_address (std::string address) { representative_address_impl (address, ec, block); build_state |= build_flags::representative_present; return *this; } -rai::change_block_builder & rai::change_block_builder::previous (rai::block_hash previous) +nano::change_block_builder & nano::change_block_builder::previous (nano::block_hash previous) { block->hashables.previous = previous; build_state |= build_flags::previous_present; return *this; } -rai::change_block_builder & rai::change_block_builder::previous_hex (std::string previous_hex) +nano::change_block_builder & nano::change_block_builder::previous_hex (std::string previous_hex) { previous_hex_impl (previous_hex, ec, block); build_state |= build_flags::previous_present; return *this; } -rai::send_block_builder::send_block_builder () +nano::send_block_builder::send_block_builder () { make_block (); } -rai::send_block_builder & rai::send_block_builder::make_block () +nano::send_block_builder & nano::send_block_builder::make_block () { construct_block (); return *this; } -void rai::send_block_builder::validate () +void nano::send_block_builder::validate () { if (!ec) { @@ -507,7 +507,7 @@ void rai::send_block_builder::validate () } } -rai::send_block_builder & rai::send_block_builder::zero () +nano::send_block_builder & nano::send_block_builder::zero () { block->work = uint64_t (0); block->signature.clear (); @@ -518,74 +518,74 @@ rai::send_block_builder & rai::send_block_builder::zero () return *this; } -rai::send_block_builder & rai::send_block_builder::destination (rai::account account) +nano::send_block_builder & nano::send_block_builder::destination (nano::account account) { block->hashables.destination = account; build_state |= build_flags::link_present; return *this; } -rai::send_block_builder & rai::send_block_builder::destination_hex (std::string account_hex) +nano::send_block_builder & nano::send_block_builder::destination_hex (std::string account_hex) { destination_hex_impl (account_hex, ec, block); build_state |= build_flags::link_present; return *this; } -rai::send_block_builder & rai::send_block_builder::destination_address (std::string address) +nano::send_block_builder & nano::send_block_builder::destination_address (std::string address) { destination_address_impl (address, ec, block); build_state |= build_flags::link_present; return *this; } -rai::send_block_builder & rai::send_block_builder::previous (rai::block_hash previous) +nano::send_block_builder & nano::send_block_builder::previous (nano::block_hash previous) { block->hashables.previous = previous; build_state |= build_flags::previous_present; return *this; } -rai::send_block_builder & rai::send_block_builder::previous_hex (std::string previous_hex) +nano::send_block_builder & nano::send_block_builder::previous_hex (std::string previous_hex) { previous_hex_impl (previous_hex, ec, block); build_state |= build_flags::previous_present; return *this; } -rai::send_block_builder & rai::send_block_builder::balance (rai::amount balance) +nano::send_block_builder & nano::send_block_builder::balance (nano::amount balance) { block->hashables.balance = balance; build_state |= build_flags::balance_present; return *this; } -rai::send_block_builder & rai::send_block_builder::balance_dec (std::string balance_decimal) +nano::send_block_builder & nano::send_block_builder::balance_dec (std::string balance_decimal) { balance_dec_impl (balance_decimal, ec, block); build_state |= build_flags::balance_present; return *this; } -rai::send_block_builder & rai::send_block_builder::balance_hex (std::string balance_hex) +nano::send_block_builder & nano::send_block_builder::balance_hex (std::string balance_hex) { balance_hex_impl (balance_hex, ec, block); build_state |= build_flags::balance_present; return *this; } -rai::receive_block_builder::receive_block_builder () +nano::receive_block_builder::receive_block_builder () { make_block (); } -rai::receive_block_builder & rai::receive_block_builder::make_block () +nano::receive_block_builder & nano::receive_block_builder::make_block () { construct_block (); return *this; } -void rai::receive_block_builder::validate () +void nano::receive_block_builder::validate () { if (!ec) { @@ -593,7 +593,7 @@ void rai::receive_block_builder::validate () } } -rai::receive_block_builder & rai::receive_block_builder::zero () +nano::receive_block_builder & nano::receive_block_builder::zero () { block->work = uint64_t (0); block->signature.clear (); @@ -603,28 +603,28 @@ rai::receive_block_builder & rai::receive_block_builder::zero () return *this; } -rai::receive_block_builder & rai::receive_block_builder::previous (rai::block_hash previous) +nano::receive_block_builder & nano::receive_block_builder::previous (nano::block_hash previous) { block->hashables.previous = previous; build_state |= build_flags::previous_present; return *this; } -rai::receive_block_builder & rai::receive_block_builder::previous_hex (std::string previous_hex) +nano::receive_block_builder & nano::receive_block_builder::previous_hex (std::string previous_hex) { previous_hex_impl (previous_hex, ec, block); build_state |= build_flags::previous_present; return *this; } -rai::receive_block_builder & rai::receive_block_builder::source (rai::block_hash source) +nano::receive_block_builder & nano::receive_block_builder::source (nano::block_hash source) { block->hashables.source = source; build_state |= build_flags::link_present; return *this; } -rai::receive_block_builder & rai::receive_block_builder::source_hex (std::string source_hex) +nano::receive_block_builder & nano::receive_block_builder::source_hex (std::string source_hex) { source_hex_impl (source_hex, ec, block); build_state |= build_flags::link_present; diff --git a/rai/lib/blockbuilders.hpp b/nano/lib/blockbuilders.hpp similarity index 74% rename from rai/lib/blockbuilders.hpp rename to nano/lib/blockbuilders.hpp index bbb83a7e..f03a0aec 100644 --- a/rai/lib/blockbuilders.hpp +++ b/nano/lib/blockbuilders.hpp @@ -1,10 +1,10 @@ #pragma once #include -#include -#include +#include +#include -namespace rai +namespace nano { /** Flags to track builder state */ enum class build_flags : uint8_t @@ -19,19 +19,19 @@ enum class build_flags : uint8_t representative_present = 64 }; -inline rai::build_flags operator| (rai::build_flags a, rai::build_flags b) +inline nano::build_flags operator| (nano::build_flags a, nano::build_flags b) { - return static_cast (static_cast (a) | static_cast (b)); + return static_cast (static_cast (a) | static_cast (b)); } -inline uint8_t operator| (uint8_t a, rai::build_flags b) +inline uint8_t operator| (uint8_t a, nano::build_flags b) { return static_cast (a | static_cast (b)); } -inline uint8_t operator& (uint8_t a, rai::build_flags b) +inline uint8_t operator& (uint8_t a, nano::build_flags b) { return static_cast (a & static_cast (b)); } -inline uint8_t operator|= (uint8_t & a, rai::build_flags b) +inline uint8_t operator|= (uint8_t & a, nano::build_flags b) { return a = static_cast (a | static_cast (b)); } @@ -75,9 +75,9 @@ public: } /** Sign the block using the \p private_key and \p public_key */ - inline abstract_builder & sign (rai::raw_key const & private_key, rai::public_key const & public_key) + inline abstract_builder & sign (nano::raw_key const & private_key, nano::public_key const & public_key) { - block->signature = rai::sign_message (private_key, public_key, block->hash ()); + block->signature = nano::sign_message (private_key, public_key, block->hash ()); build_state |= build_flags::signature_present; return *this; } @@ -116,11 +116,11 @@ protected: uint8_t build_state{ 0 }; /** Required field shared by all block types*/ - uint8_t base_fields = static_cast (rai::build_flags::work_present | rai::build_flags::signature_present); + uint8_t base_fields = static_cast (nano::build_flags::work_present | nano::build_flags::signature_present); }; /** Builder for state blocks */ -class state_block_builder : public abstract_builder +class state_block_builder : public abstract_builder { public: /** Creates a state block builder by calling make_block() */ @@ -130,29 +130,29 @@ public: /** Sets all hashables, signature and work to zero. */ state_block_builder & zero (); /** Set account */ - state_block_builder & account (rai::account account); + state_block_builder & account (nano::account account); /** Set account from hex representation of public key */ state_block_builder & account_hex (std::string account_hex); /** Set account from an xrb_ or nano_ address */ state_block_builder & account_address (std::string account_address); /** Set representative */ - state_block_builder & representative (rai::account account); + state_block_builder & representative (nano::account account); /** Set representative from hex representation of public key */ state_block_builder & representative_hex (std::string account_hex); /** Set representative from an xrb_ or nano_ address */ state_block_builder & representative_address (std::string account_address); /** Set previous block hash */ - state_block_builder & previous (rai::block_hash previous); + state_block_builder & previous (nano::block_hash previous); /** Set previous block hash from hex representation */ state_block_builder & previous_hex (std::string previous_hex); /** Set balance */ - state_block_builder & balance (rai::amount balance); + state_block_builder & balance (nano::amount balance); /** Set balance from decimal string */ state_block_builder & balance_dec (std::string balance_decimal); /** Set balance from hex string */ state_block_builder & balance_hex (std::string balance_hex); /** Set link */ - state_block_builder & link (rai::uint256_union link); + state_block_builder & link (nano::uint256_union link); /** Set link from hex representation */ state_block_builder & link_hex (std::string link_hex); /** Set link from an xrb_ or nano_ address */ @@ -161,11 +161,11 @@ public: void validate (); private: - uint8_t required_fields = base_fields | static_cast (rai::build_flags::account_present | rai::build_flags::balance_present | rai::build_flags::link_present | rai::build_flags::previous_present | rai::build_flags::representative_present); + uint8_t required_fields = base_fields | static_cast (nano::build_flags::account_present | nano::build_flags::balance_present | nano::build_flags::link_present | nano::build_flags::previous_present | nano::build_flags::representative_present); }; /** Builder for open blocks */ -class open_block_builder : public abstract_builder +class open_block_builder : public abstract_builder { public: /** Creates an open block builder by calling make_block() */ @@ -175,30 +175,30 @@ public: /** Sets all hashables, signature and work to zero. */ open_block_builder & zero (); /** Set account */ - open_block_builder & account (rai::account account); + open_block_builder & account (nano::account account); /** Set account from hex representation of public key */ open_block_builder & account_hex (std::string account_hex); /** Set account from an xrb_ or nano_ address */ open_block_builder & account_address (std::string account_address); /** Set representative */ - open_block_builder & representative (rai::account account); + open_block_builder & representative (nano::account account); /** Set representative from hex representation of public key */ open_block_builder & representative_hex (std::string account_hex); /** Set representative from an xrb_ or nano_ address */ open_block_builder & representative_address (std::string account_address); /** Set source block hash */ - open_block_builder & source (rai::block_hash source); + open_block_builder & source (nano::block_hash source); /** Set source block hash from hex representation */ open_block_builder & source_hex (std::string source_hex); /** Provides validation for build() */ void validate (); private: - uint8_t required_fields = base_fields | static_cast (rai::build_flags::account_present | rai::build_flags::representative_present | rai::build_flags::link_present); + uint8_t required_fields = base_fields | static_cast (nano::build_flags::account_present | nano::build_flags::representative_present | nano::build_flags::link_present); }; /** Builder for change blocks */ -class change_block_builder : public abstract_builder +class change_block_builder : public abstract_builder { public: /** Create a change block builder by calling make_block() */ @@ -208,24 +208,24 @@ public: /** Sets all hashables, signature and work to zero. */ change_block_builder & zero (); /** Set representative */ - change_block_builder & representative (rai::account account); + change_block_builder & representative (nano::account account); /** Set representative from hex representation of public key */ change_block_builder & representative_hex (std::string account_hex); /** Set representative from an xrb_ or nano_ address */ change_block_builder & representative_address (std::string account_address); /** Set previous block hash */ - change_block_builder & previous (rai::block_hash previous); + change_block_builder & previous (nano::block_hash previous); /** Set previous block hash from hex representation */ change_block_builder & previous_hex (std::string previous_hex); /** Provides validation for build() */ void validate (); private: - uint8_t required_fields = base_fields | static_cast (rai::build_flags::previous_present | rai::build_flags::representative_present); + uint8_t required_fields = base_fields | static_cast (nano::build_flags::previous_present | nano::build_flags::representative_present); }; /** Builder for send blocks */ -class send_block_builder : public abstract_builder +class send_block_builder : public abstract_builder { public: /** Creates a send block builder by calling make_block() */ @@ -235,17 +235,17 @@ public: /** Sets all hashables, signature and work to zero. */ send_block_builder & zero (); /** Set destination */ - send_block_builder & destination (rai::account account); + send_block_builder & destination (nano::account account); /** Set destination from hex representation of public key */ send_block_builder & destination_hex (std::string account_hex); /** Set destination from an xrb_ or nano_ address */ send_block_builder & destination_address (std::string account_address); /** Set previous block hash */ - send_block_builder & previous (rai::block_hash previous); + send_block_builder & previous (nano::block_hash previous); /** Set previous block hash from hex representation */ send_block_builder & previous_hex (std::string previous_hex); /** Set balance */ - send_block_builder & balance (rai::amount balance); + send_block_builder & balance (nano::amount balance); /** Set balance from decimal string */ send_block_builder & balance_dec (std::string balance_decimal); /** Set balance from hex string */ @@ -258,7 +258,7 @@ private: }; /** Builder for receive blocks */ -class receive_block_builder : public abstract_builder +class receive_block_builder : public abstract_builder { public: /** Creates a receive block by calling make_block() */ @@ -268,11 +268,11 @@ public: /** Sets all hashables, signature and work to zero. */ receive_block_builder & zero (); /** Set previous block hash */ - receive_block_builder & previous (rai::block_hash previous); + receive_block_builder & previous (nano::block_hash previous); /** Set previous block hash from hex representation */ receive_block_builder & previous_hex (std::string previous_hex); /** Set source block hash */ - receive_block_builder & source (rai::block_hash source); + receive_block_builder & source (nano::block_hash source); /** Set source block hash from hex representation */ receive_block_builder & source_hex (std::string source_hex); /** Provides validation for build() */ @@ -287,45 +287,45 @@ class block_builder { public: /** Prepares a new state block and returns a block builder */ - inline rai::state_block_builder & state () + inline nano::state_block_builder & state () { state_builder.make_block (); return state_builder; } /** Prepares a new open block and returns a block builder */ - inline rai::open_block_builder & open () + inline nano::open_block_builder & open () { open_builder.make_block (); return open_builder; } /** Prepares a new change block and returns a block builder */ - inline rai::change_block_builder & change () + inline nano::change_block_builder & change () { change_builder.make_block (); return change_builder; } /** Prepares a new send block and returns a block builder */ - inline rai::send_block_builder & send () + inline nano::send_block_builder & send () { send_builder.make_block (); return send_builder; } /** Prepares a new receive block and returns a block builder */ - inline rai::receive_block_builder & receive () + inline nano::receive_block_builder & receive () { receive_builder.make_block (); return receive_builder; } private: - rai::state_block_builder state_builder; - rai::open_block_builder open_builder; - rai::change_block_builder change_builder; - rai::send_block_builder send_builder; - rai::receive_block_builder receive_builder; + nano::state_block_builder state_builder; + nano::open_block_builder open_builder; + nano::change_block_builder change_builder; + nano::send_block_builder send_builder; + nano::receive_block_builder receive_builder; }; } diff --git a/rai/lib/blocks.cpp b/nano/lib/blocks.cpp similarity index 61% rename from rai/lib/blocks.cpp rename to nano/lib/blocks.cpp index 212ebbef..0538383f 100644 --- a/rai/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -1,5 +1,5 @@ -#include -#include +#include +#include #include @@ -9,14 +9,14 @@ namespace { template -bool blocks_equal (T const & first, rai::block const & second) +bool blocks_equal (T const & first, nano::block const & second) { - static_assert (std::is_base_of::value, "Input parameter is not a block type"); + static_assert (std::is_base_of::value, "Input parameter is not a block type"); return (first.type () == second.type ()) && (static_cast (second)) == first; } } -std::string rai::to_string_hex (uint64_t value_a) +std::string nano::to_string_hex (uint64_t value_a) { std::stringstream stream; stream << std::hex << std::noshowbase << std::setw (16) << std::setfill ('0'); @@ -24,7 +24,7 @@ std::string rai::to_string_hex (uint64_t value_a) return stream.str (); } -bool rai::from_string_hex (std::string const & value_a, uint64_t & target_a) +bool nano::from_string_hex (std::string const & value_a, uint64_t & target_a) { auto error (value_a.empty ()); if (!error) @@ -53,16 +53,16 @@ bool rai::from_string_hex (std::string const & value_a, uint64_t & target_a) return error; } -std::string rai::block::to_json () +std::string nano::block::to_json () { std::string result; serialize_json (result); return result; } -rai::block_hash rai::block::hash () const +nano::block_hash nano::block::hash () const { - rai::uint256_union result; + nano::uint256_union result; blake2b_state hash_l; auto status (blake2b_init (&hash_l, sizeof (result.bytes))); assert (status == 0); @@ -72,9 +72,9 @@ rai::block_hash rai::block::hash () const return result; } -rai::block_hash rai::block::full_hash () const +nano::block_hash nano::block::full_hash () const { - rai::block_hash result; + nano::block_hash result; blake2b_state state; blake2b_init (&state, sizeof (result.bytes)); blake2b_update (&state, hash ().bytes.data (), sizeof (hash ())); @@ -86,47 +86,47 @@ rai::block_hash rai::block::full_hash () const return result; } -void rai::send_block::visit (rai::block_visitor & visitor_a) const +void nano::send_block::visit (nano::block_visitor & visitor_a) const { visitor_a.send_block (*this); } -void rai::send_block::hash (blake2b_state & hash_a) const +void nano::send_block::hash (blake2b_state & hash_a) const { hashables.hash (hash_a); } -uint64_t rai::send_block::block_work () const +uint64_t nano::send_block::block_work () const { return work; } -void rai::send_block::block_work_set (uint64_t work_a) +void nano::send_block::block_work_set (uint64_t work_a) { work = work_a; } -rai::send_hashables::send_hashables (rai::block_hash const & previous_a, rai::account const & destination_a, rai::amount const & balance_a) : +nano::send_hashables::send_hashables (nano::block_hash const & previous_a, nano::account const & destination_a, nano::amount const & balance_a) : previous (previous_a), destination (destination_a), balance (balance_a) { } -rai::send_hashables::send_hashables (bool & error_a, rai::stream & stream_a) +nano::send_hashables::send_hashables (bool & error_a, nano::stream & stream_a) { - error_a = rai::read (stream_a, previous.bytes); + error_a = nano::read (stream_a, previous.bytes); if (!error_a) { - error_a = rai::read (stream_a, destination.bytes); + error_a = nano::read (stream_a, destination.bytes); if (!error_a) { - error_a = rai::read (stream_a, balance.bytes); + error_a = nano::read (stream_a, balance.bytes); } } } -rai::send_hashables::send_hashables (bool & error_a, boost::property_tree::ptree const & tree_a) +nano::send_hashables::send_hashables (bool & error_a, boost::property_tree::ptree const & tree_a) { try { @@ -149,7 +149,7 @@ rai::send_hashables::send_hashables (bool & error_a, boost::property_tree::ptree } } -void rai::send_hashables::hash (blake2b_state & hash_a) const +void nano::send_hashables::hash (blake2b_state & hash_a) const { auto status (blake2b_update (&hash_a, previous.bytes.data (), sizeof (previous.bytes))); assert (status == 0); @@ -159,7 +159,7 @@ void rai::send_hashables::hash (blake2b_state & hash_a) const assert (status == 0); } -void rai::send_block::serialize (rai::stream & stream_a) const +void nano::send_block::serialize (nano::stream & stream_a) const { write (stream_a, hashables.previous.bytes); write (stream_a, hashables.destination.bytes); @@ -168,7 +168,7 @@ void rai::send_block::serialize (rai::stream & stream_a) const write (stream_a, work); } -void rai::send_block::serialize_json (std::string & string_a) const +void nano::send_block::serialize_json (std::string & string_a) const { boost::property_tree::ptree tree; tree.put ("type", "send"); @@ -181,14 +181,14 @@ void rai::send_block::serialize_json (std::string & string_a) const tree.put ("balance", balance); std::string signature_l; signature.encode_hex (signature_l); - tree.put ("work", rai::to_string_hex (work)); + tree.put ("work", nano::to_string_hex (work)); tree.put ("signature", signature_l); std::stringstream ostream; boost::property_tree::write_json (ostream, tree); string_a = ostream.str (); } -bool rai::send_block::deserialize (rai::stream & stream_a) +bool nano::send_block::deserialize (nano::stream & stream_a) { auto error (false); error = read (stream_a, hashables.previous.bytes); @@ -211,7 +211,7 @@ bool rai::send_block::deserialize (rai::stream & stream_a) return error; } -bool rai::send_block::deserialize_json (boost::property_tree::ptree const & tree_a) +bool nano::send_block::deserialize_json (boost::property_tree::ptree const & tree_a) { auto error (false); try @@ -231,7 +231,7 @@ bool rai::send_block::deserialize_json (boost::property_tree::ptree const & tree error = hashables.balance.decode_hex (balance_l); if (!error) { - error = rai::from_string_hex (work_l, work); + error = nano::from_string_hex (work_l, work); if (!error) { error = signature.decode_hex (signature_l); @@ -247,27 +247,27 @@ bool rai::send_block::deserialize_json (boost::property_tree::ptree const & tree return error; } -rai::send_block::send_block (rai::block_hash const & previous_a, rai::account const & destination_a, rai::amount const & balance_a, rai::raw_key const & prv_a, rai::public_key const & pub_a, uint64_t work_a) : +nano::send_block::send_block (nano::block_hash const & previous_a, nano::account const & destination_a, nano::amount const & balance_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) : hashables (previous_a, destination_a, balance_a), -signature (rai::sign_message (prv_a, pub_a, hash ())), +signature (nano::sign_message (prv_a, pub_a, hash ())), work (work_a) { } -rai::send_block::send_block (bool & error_a, rai::stream & stream_a) : +nano::send_block::send_block (bool & error_a, nano::stream & stream_a) : hashables (error_a, stream_a) { if (!error_a) { - error_a = rai::read (stream_a, signature.bytes); + error_a = nano::read (stream_a, signature.bytes); if (!error_a) { - error_a = rai::read (stream_a, work); + error_a = nano::read (stream_a, work); } } } -rai::send_block::send_block (bool & error_a, boost::property_tree::ptree const & tree_a) : +nano::send_block::send_block (bool & error_a, boost::property_tree::ptree const & tree_a) : hashables (error_a, tree_a) { if (!error_a) @@ -279,7 +279,7 @@ hashables (error_a, tree_a) error_a = signature.decode_hex (signature_l); if (!error_a) { - error_a = rai::from_string_hex (work_l, work); + error_a = nano::from_string_hex (work_l, work); } } catch (std::runtime_error const &) @@ -289,20 +289,20 @@ hashables (error_a, tree_a) } } -bool rai::send_block::operator== (rai::block const & other_a) const +bool nano::send_block::operator== (nano::block const & other_a) const { return blocks_equal (*this, other_a); } -bool rai::send_block::valid_predecessor (rai::block const & block_a) const +bool nano::send_block::valid_predecessor (nano::block const & block_a) const { bool result; switch (block_a.type ()) { - case rai::block_type::send: - case rai::block_type::receive: - case rai::block_type::open: - case rai::block_type::change: + case nano::block_type::send: + case nano::block_type::receive: + case nano::block_type::open: + case nano::block_type::change: result = true; break; default: @@ -312,73 +312,73 @@ bool rai::send_block::valid_predecessor (rai::block const & block_a) const return result; } -rai::block_type rai::send_block::type () const +nano::block_type nano::send_block::type () const { - return rai::block_type::send; + return nano::block_type::send; } -bool rai::send_block::operator== (rai::send_block const & other_a) const +bool nano::send_block::operator== (nano::send_block const & other_a) const { auto result (hashables.destination == other_a.hashables.destination && hashables.previous == other_a.hashables.previous && hashables.balance == other_a.hashables.balance && work == other_a.work && signature == other_a.signature); return result; } -rai::block_hash rai::send_block::previous () const +nano::block_hash nano::send_block::previous () const { return hashables.previous; } -rai::block_hash rai::send_block::source () const +nano::block_hash nano::send_block::source () const { return 0; } -rai::block_hash rai::send_block::root () const +nano::block_hash nano::send_block::root () const { return hashables.previous; } -rai::block_hash rai::send_block::link () const +nano::block_hash nano::send_block::link () const { return 0; } -rai::account rai::send_block::representative () const +nano::account nano::send_block::representative () const { return 0; } -rai::signature rai::send_block::block_signature () const +nano::signature nano::send_block::block_signature () const { return signature; } -void rai::send_block::signature_set (rai::uint512_union const & signature_a) +void nano::send_block::signature_set (nano::uint512_union const & signature_a) { signature = signature_a; } -rai::open_hashables::open_hashables (rai::block_hash const & source_a, rai::account const & representative_a, rai::account const & account_a) : +nano::open_hashables::open_hashables (nano::block_hash const & source_a, nano::account const & representative_a, nano::account const & account_a) : source (source_a), representative (representative_a), account (account_a) { } -rai::open_hashables::open_hashables (bool & error_a, rai::stream & stream_a) +nano::open_hashables::open_hashables (bool & error_a, nano::stream & stream_a) { - error_a = rai::read (stream_a, source.bytes); + error_a = nano::read (stream_a, source.bytes); if (!error_a) { - error_a = rai::read (stream_a, representative.bytes); + error_a = nano::read (stream_a, representative.bytes); if (!error_a) { - error_a = rai::read (stream_a, account.bytes); + error_a = nano::read (stream_a, account.bytes); } } } -rai::open_hashables::open_hashables (bool & error_a, boost::property_tree::ptree const & tree_a) +nano::open_hashables::open_hashables (bool & error_a, boost::property_tree::ptree const & tree_a) { try { @@ -401,42 +401,42 @@ rai::open_hashables::open_hashables (bool & error_a, boost::property_tree::ptree } } -void rai::open_hashables::hash (blake2b_state & hash_a) const +void nano::open_hashables::hash (blake2b_state & hash_a) const { blake2b_update (&hash_a, source.bytes.data (), sizeof (source.bytes)); blake2b_update (&hash_a, representative.bytes.data (), sizeof (representative.bytes)); blake2b_update (&hash_a, account.bytes.data (), sizeof (account.bytes)); } -rai::open_block::open_block (rai::block_hash const & source_a, rai::account const & representative_a, rai::account const & account_a, rai::raw_key const & prv_a, rai::public_key const & pub_a, uint64_t work_a) : +nano::open_block::open_block (nano::block_hash const & source_a, nano::account const & representative_a, nano::account const & account_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) : hashables (source_a, representative_a, account_a), -signature (rai::sign_message (prv_a, pub_a, hash ())), +signature (nano::sign_message (prv_a, pub_a, hash ())), work (work_a) { assert (!representative_a.is_zero ()); } -rai::open_block::open_block (rai::block_hash const & source_a, rai::account const & representative_a, rai::account const & account_a, std::nullptr_t) : +nano::open_block::open_block (nano::block_hash const & source_a, nano::account const & representative_a, nano::account const & account_a, std::nullptr_t) : hashables (source_a, representative_a, account_a), work (0) { signature.clear (); } -rai::open_block::open_block (bool & error_a, rai::stream & stream_a) : +nano::open_block::open_block (bool & error_a, nano::stream & stream_a) : hashables (error_a, stream_a) { if (!error_a) { - error_a = rai::read (stream_a, signature); + error_a = nano::read (stream_a, signature); if (!error_a) { - error_a = rai::read (stream_a, work); + error_a = nano::read (stream_a, work); } } } -rai::open_block::open_block (bool & error_a, boost::property_tree::ptree const & tree_a) : +nano::open_block::open_block (bool & error_a, boost::property_tree::ptree const & tree_a) : hashables (error_a, tree_a) { if (!error_a) @@ -445,7 +445,7 @@ hashables (error_a, tree_a) { auto work_l (tree_a.get ("work")); auto signature_l (tree_a.get ("signature")); - error_a = rai::from_string_hex (work_l, work); + error_a = nano::from_string_hex (work_l, work); if (!error_a) { error_a = signature.decode_hex (signature_l); @@ -458,28 +458,28 @@ hashables (error_a, tree_a) } } -void rai::open_block::hash (blake2b_state & hash_a) const +void nano::open_block::hash (blake2b_state & hash_a) const { hashables.hash (hash_a); } -uint64_t rai::open_block::block_work () const +uint64_t nano::open_block::block_work () const { return work; } -void rai::open_block::block_work_set (uint64_t work_a) +void nano::open_block::block_work_set (uint64_t work_a) { work = work_a; } -rai::block_hash rai::open_block::previous () const +nano::block_hash nano::open_block::previous () const { - rai::block_hash result (0); + nano::block_hash result (0); return result; } -void rai::open_block::serialize (rai::stream & stream_a) const +void nano::open_block::serialize (nano::stream & stream_a) const { write (stream_a, hashables.source); write (stream_a, hashables.representative); @@ -488,7 +488,7 @@ void rai::open_block::serialize (rai::stream & stream_a) const write (stream_a, work); } -void rai::open_block::serialize_json (std::string & string_a) const +void nano::open_block::serialize_json (std::string & string_a) const { boost::property_tree::ptree tree; tree.put ("type", "open"); @@ -497,14 +497,14 @@ void rai::open_block::serialize_json (std::string & string_a) const tree.put ("account", hashables.account.to_account ()); std::string signature_l; signature.encode_hex (signature_l); - tree.put ("work", rai::to_string_hex (work)); + tree.put ("work", nano::to_string_hex (work)); tree.put ("signature", signature_l); std::stringstream ostream; boost::property_tree::write_json (ostream, tree); string_a = ostream.str (); } -bool rai::open_block::deserialize (rai::stream & stream_a) +bool nano::open_block::deserialize (nano::stream & stream_a) { auto error (read (stream_a, hashables.source)); if (!error) @@ -526,7 +526,7 @@ bool rai::open_block::deserialize (rai::stream & stream_a) return error; } -bool rai::open_block::deserialize_json (boost::property_tree::ptree const & tree_a) +bool nano::open_block::deserialize_json (boost::property_tree::ptree const & tree_a) { auto error (false); try @@ -546,7 +546,7 @@ bool rai::open_block::deserialize_json (boost::property_tree::ptree const & tree error = hashables.account.decode_hex (account_l); if (!error) { - error = rai::from_string_hex (work_l, work); + error = nano::from_string_hex (work_l, work); if (!error) { error = signature.decode_hex (signature_l); @@ -562,77 +562,77 @@ bool rai::open_block::deserialize_json (boost::property_tree::ptree const & tree return error; } -void rai::open_block::visit (rai::block_visitor & visitor_a) const +void nano::open_block::visit (nano::block_visitor & visitor_a) const { visitor_a.open_block (*this); } -rai::block_type rai::open_block::type () const +nano::block_type nano::open_block::type () const { - return rai::block_type::open; + return nano::block_type::open; } -bool rai::open_block::operator== (rai::block const & other_a) const +bool nano::open_block::operator== (nano::block const & other_a) const { return blocks_equal (*this, other_a); } -bool rai::open_block::operator== (rai::open_block const & other_a) const +bool nano::open_block::operator== (nano::open_block const & other_a) const { return hashables.source == other_a.hashables.source && hashables.representative == other_a.hashables.representative && hashables.account == other_a.hashables.account && work == other_a.work && signature == other_a.signature; } -bool rai::open_block::valid_predecessor (rai::block const & block_a) const +bool nano::open_block::valid_predecessor (nano::block const & block_a) const { return false; } -rai::block_hash rai::open_block::source () const +nano::block_hash nano::open_block::source () const { return hashables.source; } -rai::block_hash rai::open_block::root () const +nano::block_hash nano::open_block::root () const { return hashables.account; } -rai::block_hash rai::open_block::link () const +nano::block_hash nano::open_block::link () const { return 0; } -rai::account rai::open_block::representative () const +nano::account nano::open_block::representative () const { return hashables.representative; } -rai::signature rai::open_block::block_signature () const +nano::signature nano::open_block::block_signature () const { return signature; } -void rai::open_block::signature_set (rai::uint512_union const & signature_a) +void nano::open_block::signature_set (nano::uint512_union const & signature_a) { signature = signature_a; } -rai::change_hashables::change_hashables (rai::block_hash const & previous_a, rai::account const & representative_a) : +nano::change_hashables::change_hashables (nano::block_hash const & previous_a, nano::account const & representative_a) : previous (previous_a), representative (representative_a) { } -rai::change_hashables::change_hashables (bool & error_a, rai::stream & stream_a) +nano::change_hashables::change_hashables (bool & error_a, nano::stream & stream_a) { - error_a = rai::read (stream_a, previous); + error_a = nano::read (stream_a, previous); if (!error_a) { - error_a = rai::read (stream_a, representative); + error_a = nano::read (stream_a, representative); } } -rai::change_hashables::change_hashables (bool & error_a, boost::property_tree::ptree const & tree_a) +nano::change_hashables::change_hashables (bool & error_a, boost::property_tree::ptree const & tree_a) { try { @@ -650,33 +650,33 @@ rai::change_hashables::change_hashables (bool & error_a, boost::property_tree::p } } -void rai::change_hashables::hash (blake2b_state & hash_a) const +void nano::change_hashables::hash (blake2b_state & hash_a) const { blake2b_update (&hash_a, previous.bytes.data (), sizeof (previous.bytes)); blake2b_update (&hash_a, representative.bytes.data (), sizeof (representative.bytes)); } -rai::change_block::change_block (rai::block_hash const & previous_a, rai::account const & representative_a, rai::raw_key const & prv_a, rai::public_key const & pub_a, uint64_t work_a) : +nano::change_block::change_block (nano::block_hash const & previous_a, nano::account const & representative_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) : hashables (previous_a, representative_a), -signature (rai::sign_message (prv_a, pub_a, hash ())), +signature (nano::sign_message (prv_a, pub_a, hash ())), work (work_a) { } -rai::change_block::change_block (bool & error_a, rai::stream & stream_a) : +nano::change_block::change_block (bool & error_a, nano::stream & stream_a) : hashables (error_a, stream_a) { if (!error_a) { - error_a = rai::read (stream_a, signature); + error_a = nano::read (stream_a, signature); if (!error_a) { - error_a = rai::read (stream_a, work); + error_a = nano::read (stream_a, work); } } } -rai::change_block::change_block (bool & error_a, boost::property_tree::ptree const & tree_a) : +nano::change_block::change_block (bool & error_a, boost::property_tree::ptree const & tree_a) : hashables (error_a, tree_a) { if (!error_a) @@ -685,7 +685,7 @@ hashables (error_a, tree_a) { auto work_l (tree_a.get ("work")); auto signature_l (tree_a.get ("signature")); - error_a = rai::from_string_hex (work_l, work); + error_a = nano::from_string_hex (work_l, work); if (!error_a) { error_a = signature.decode_hex (signature_l); @@ -698,27 +698,27 @@ hashables (error_a, tree_a) } } -void rai::change_block::hash (blake2b_state & hash_a) const +void nano::change_block::hash (blake2b_state & hash_a) const { hashables.hash (hash_a); } -uint64_t rai::change_block::block_work () const +uint64_t nano::change_block::block_work () const { return work; } -void rai::change_block::block_work_set (uint64_t work_a) +void nano::change_block::block_work_set (uint64_t work_a) { work = work_a; } -rai::block_hash rai::change_block::previous () const +nano::block_hash nano::change_block::previous () const { return hashables.previous; } -void rai::change_block::serialize (rai::stream & stream_a) const +void nano::change_block::serialize (nano::stream & stream_a) const { write (stream_a, hashables.previous); write (stream_a, hashables.representative); @@ -726,13 +726,13 @@ void rai::change_block::serialize (rai::stream & stream_a) const write (stream_a, work); } -void rai::change_block::serialize_json (std::string & string_a) const +void nano::change_block::serialize_json (std::string & string_a) const { boost::property_tree::ptree tree; tree.put ("type", "change"); tree.put ("previous", hashables.previous.to_string ()); tree.put ("representative", representative ().to_account ()); - tree.put ("work", rai::to_string_hex (work)); + tree.put ("work", nano::to_string_hex (work)); std::string signature_l; signature.encode_hex (signature_l); tree.put ("signature", signature_l); @@ -741,7 +741,7 @@ void rai::change_block::serialize_json (std::string & string_a) const string_a = ostream.str (); } -bool rai::change_block::deserialize (rai::stream & stream_a) +bool nano::change_block::deserialize (nano::stream & stream_a) { auto error (read (stream_a, hashables.previous)); if (!error) @@ -759,7 +759,7 @@ bool rai::change_block::deserialize (rai::stream & stream_a) return error; } -bool rai::change_block::deserialize_json (boost::property_tree::ptree const & tree_a) +bool nano::change_block::deserialize_json (boost::property_tree::ptree const & tree_a) { auto error (false); try @@ -775,7 +775,7 @@ bool rai::change_block::deserialize_json (boost::property_tree::ptree const & tr error = hashables.representative.decode_hex (representative_l); if (!error) { - error = rai::from_string_hex (work_l, work); + error = nano::from_string_hex (work_l, work); if (!error) { error = signature.decode_hex (signature_l); @@ -790,35 +790,35 @@ bool rai::change_block::deserialize_json (boost::property_tree::ptree const & tr return error; } -void rai::change_block::visit (rai::block_visitor & visitor_a) const +void nano::change_block::visit (nano::block_visitor & visitor_a) const { visitor_a.change_block (*this); } -rai::block_type rai::change_block::type () const +nano::block_type nano::change_block::type () const { - return rai::block_type::change; + return nano::block_type::change; } -bool rai::change_block::operator== (rai::block const & other_a) const +bool nano::change_block::operator== (nano::block const & other_a) const { return blocks_equal (*this, other_a); } -bool rai::change_block::operator== (rai::change_block const & other_a) const +bool nano::change_block::operator== (nano::change_block const & other_a) const { return hashables.previous == other_a.hashables.previous && hashables.representative == other_a.hashables.representative && work == other_a.work && signature == other_a.signature; } -bool rai::change_block::valid_predecessor (rai::block const & block_a) const +bool nano::change_block::valid_predecessor (nano::block const & block_a) const { bool result; switch (block_a.type ()) { - case rai::block_type::send: - case rai::block_type::receive: - case rai::block_type::open: - case rai::block_type::change: + case nano::block_type::send: + case nano::block_type::receive: + case nano::block_type::open: + case nano::block_type::change: result = true; break; default: @@ -828,37 +828,37 @@ bool rai::change_block::valid_predecessor (rai::block const & block_a) const return result; } -rai::block_hash rai::change_block::source () const +nano::block_hash nano::change_block::source () const { return 0; } -rai::block_hash rai::change_block::root () const +nano::block_hash nano::change_block::root () const { return hashables.previous; } -rai::block_hash rai::change_block::link () const +nano::block_hash nano::change_block::link () const { return 0; } -rai::account rai::change_block::representative () const +nano::account nano::change_block::representative () const { return hashables.representative; } -rai::signature rai::change_block::block_signature () const +nano::signature nano::change_block::block_signature () const { return signature; } -void rai::change_block::signature_set (rai::uint512_union const & signature_a) +void nano::change_block::signature_set (nano::uint512_union const & signature_a) { signature = signature_a; } -rai::state_hashables::state_hashables (rai::account const & account_a, rai::block_hash const & previous_a, rai::account const & representative_a, rai::amount const & balance_a, rai::uint256_union const & link_a) : +nano::state_hashables::state_hashables (nano::account const & account_a, nano::block_hash const & previous_a, nano::account const & representative_a, nano::amount const & balance_a, nano::uint256_union const & link_a) : account (account_a), previous (previous_a), representative (representative_a), @@ -867,28 +867,28 @@ link (link_a) { } -rai::state_hashables::state_hashables (bool & error_a, rai::stream & stream_a) +nano::state_hashables::state_hashables (bool & error_a, nano::stream & stream_a) { - error_a = rai::read (stream_a, account); + error_a = nano::read (stream_a, account); if (!error_a) { - error_a = rai::read (stream_a, previous); + error_a = nano::read (stream_a, previous); if (!error_a) { - error_a = rai::read (stream_a, representative); + error_a = nano::read (stream_a, representative); if (!error_a) { - error_a = rai::read (stream_a, balance); + error_a = nano::read (stream_a, balance); if (!error_a) { - error_a = rai::read (stream_a, link); + error_a = nano::read (stream_a, link); } } } } } -rai::state_hashables::state_hashables (bool & error_a, boost::property_tree::ptree const & tree_a) +nano::state_hashables::state_hashables (bool & error_a, boost::property_tree::ptree const & tree_a) { try { @@ -921,7 +921,7 @@ rai::state_hashables::state_hashables (bool & error_a, boost::property_tree::ptr } } -void rai::state_hashables::hash (blake2b_state & hash_a) const +void nano::state_hashables::hash (blake2b_state & hash_a) const { blake2b_update (&hash_a, account.bytes.data (), sizeof (account.bytes)); blake2b_update (&hash_a, previous.bytes.data (), sizeof (previous.bytes)); @@ -930,28 +930,28 @@ void rai::state_hashables::hash (blake2b_state & hash_a) const blake2b_update (&hash_a, link.bytes.data (), sizeof (link.bytes)); } -rai::state_block::state_block (rai::account const & account_a, rai::block_hash const & previous_a, rai::account const & representative_a, rai::amount const & balance_a, rai::uint256_union const & link_a, rai::raw_key const & prv_a, rai::public_key const & pub_a, uint64_t work_a) : +nano::state_block::state_block (nano::account const & account_a, nano::block_hash const & previous_a, nano::account const & representative_a, nano::amount const & balance_a, nano::uint256_union const & link_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) : hashables (account_a, previous_a, representative_a, balance_a, link_a), -signature (rai::sign_message (prv_a, pub_a, hash ())), +signature (nano::sign_message (prv_a, pub_a, hash ())), work (work_a) { } -rai::state_block::state_block (bool & error_a, rai::stream & stream_a) : +nano::state_block::state_block (bool & error_a, nano::stream & stream_a) : hashables (error_a, stream_a) { if (!error_a) { - error_a = rai::read (stream_a, signature); + error_a = nano::read (stream_a, signature); if (!error_a) { - error_a = rai::read (stream_a, work); + error_a = nano::read (stream_a, work); boost::endian::big_to_native_inplace (work); } } } -rai::state_block::state_block (bool & error_a, boost::property_tree::ptree const & tree_a) : +nano::state_block::state_block (bool & error_a, boost::property_tree::ptree const & tree_a) : hashables (error_a, tree_a) { if (!error_a) @@ -964,7 +964,7 @@ hashables (error_a, tree_a) error_a = type_l != "state"; if (!error_a) { - error_a = rai::from_string_hex (work_l, work); + error_a = nano::from_string_hex (work_l, work); if (!error_a) { error_a = signature.decode_hex (signature_l); @@ -978,29 +978,29 @@ hashables (error_a, tree_a) } } -void rai::state_block::hash (blake2b_state & hash_a) const +void nano::state_block::hash (blake2b_state & hash_a) const { - rai::uint256_union preamble (static_cast (rai::block_type::state)); + nano::uint256_union preamble (static_cast (nano::block_type::state)); blake2b_update (&hash_a, preamble.bytes.data (), preamble.bytes.size ()); hashables.hash (hash_a); } -uint64_t rai::state_block::block_work () const +uint64_t nano::state_block::block_work () const { return work; } -void rai::state_block::block_work_set (uint64_t work_a) +void nano::state_block::block_work_set (uint64_t work_a) { work = work_a; } -rai::block_hash rai::state_block::previous () const +nano::block_hash nano::state_block::previous () const { return hashables.previous; } -void rai::state_block::serialize (rai::stream & stream_a) const +void nano::state_block::serialize (nano::stream & stream_a) const { write (stream_a, hashables.account); write (stream_a, hashables.previous); @@ -1011,7 +1011,7 @@ void rai::state_block::serialize (rai::stream & stream_a) const write (stream_a, boost::endian::native_to_big (work)); } -void rai::state_block::serialize_json (std::string & string_a) const +void nano::state_block::serialize_json (std::string & string_a) const { boost::property_tree::ptree tree; tree.put ("type", "state"); @@ -1024,13 +1024,13 @@ void rai::state_block::serialize_json (std::string & string_a) const std::string signature_l; signature.encode_hex (signature_l); tree.put ("signature", signature_l); - tree.put ("work", rai::to_string_hex (work)); + tree.put ("work", nano::to_string_hex (work)); std::stringstream ostream; boost::property_tree::write_json (ostream, tree); string_a = ostream.str (); } -bool rai::state_block::deserialize (rai::stream & stream_a) +bool nano::state_block::deserialize (nano::stream & stream_a) { auto error (read (stream_a, hashables.account)); if (!error) @@ -1061,7 +1061,7 @@ bool rai::state_block::deserialize (rai::stream & stream_a) return error; } -bool rai::state_block::deserialize_json (boost::property_tree::ptree const & tree_a) +bool nano::state_block::deserialize_json (boost::property_tree::ptree const & tree_a) { auto error (false); try @@ -1089,7 +1089,7 @@ bool rai::state_block::deserialize_json (boost::property_tree::ptree const & tre error = hashables.link.decode_account (link_l) && hashables.link.decode_hex (link_l); if (!error) { - error = rai::from_string_hex (work_l, work); + error = nano::from_string_hex (work_l, work); if (!error) { error = signature.decode_hex (signature_l); @@ -1107,71 +1107,71 @@ bool rai::state_block::deserialize_json (boost::property_tree::ptree const & tre return error; } -void rai::state_block::visit (rai::block_visitor & visitor_a) const +void nano::state_block::visit (nano::block_visitor & visitor_a) const { visitor_a.state_block (*this); } -rai::block_type rai::state_block::type () const +nano::block_type nano::state_block::type () const { - return rai::block_type::state; + return nano::block_type::state; } -bool rai::state_block::operator== (rai::block const & other_a) const +bool nano::state_block::operator== (nano::block const & other_a) const { return blocks_equal (*this, other_a); } -bool rai::state_block::operator== (rai::state_block const & other_a) const +bool nano::state_block::operator== (nano::state_block const & other_a) const { return hashables.account == other_a.hashables.account && hashables.previous == other_a.hashables.previous && hashables.representative == other_a.hashables.representative && hashables.balance == other_a.hashables.balance && hashables.link == other_a.hashables.link && signature == other_a.signature && work == other_a.work; } -bool rai::state_block::valid_predecessor (rai::block const & block_a) const +bool nano::state_block::valid_predecessor (nano::block const & block_a) const { return true; } -rai::block_hash rai::state_block::source () const +nano::block_hash nano::state_block::source () const { return 0; } -rai::block_hash rai::state_block::root () const +nano::block_hash nano::state_block::root () const { return !hashables.previous.is_zero () ? hashables.previous : hashables.account; } -rai::block_hash rai::state_block::link () const +nano::block_hash nano::state_block::link () const { return hashables.link; } -rai::account rai::state_block::representative () const +nano::account nano::state_block::representative () const { return hashables.representative; } -rai::signature rai::state_block::block_signature () const +nano::signature nano::state_block::block_signature () const { return signature; } -void rai::state_block::signature_set (rai::uint512_union const & signature_a) +void nano::state_block::signature_set (nano::uint512_union const & signature_a) { signature = signature_a; } -std::shared_ptr rai::deserialize_block_json (boost::property_tree::ptree const & tree_a, rai::block_uniquer * uniquer_a) +std::shared_ptr nano::deserialize_block_json (boost::property_tree::ptree const & tree_a, nano::block_uniquer * uniquer_a) { - std::shared_ptr result; + std::shared_ptr result; try { auto type (tree_a.get ("type")); if (type == "receive") { bool error (false); - std::unique_ptr obj (new rai::receive_block (error, tree_a)); + std::unique_ptr obj (new nano::receive_block (error, tree_a)); if (!error) { result = std::move (obj); @@ -1180,7 +1180,7 @@ std::shared_ptr rai::deserialize_block_json (boost::property_tree::p else if (type == "send") { bool error (false); - std::unique_ptr obj (new rai::send_block (error, tree_a)); + std::unique_ptr obj (new nano::send_block (error, tree_a)); if (!error) { result = std::move (obj); @@ -1189,7 +1189,7 @@ std::shared_ptr rai::deserialize_block_json (boost::property_tree::p else if (type == "open") { bool error (false); - std::unique_ptr obj (new rai::open_block (error, tree_a)); + std::unique_ptr obj (new nano::open_block (error, tree_a)); if (!error) { result = std::move (obj); @@ -1198,7 +1198,7 @@ std::shared_ptr rai::deserialize_block_json (boost::property_tree::p else if (type == "change") { bool error (false); - std::unique_ptr obj (new rai::change_block (error, tree_a)); + std::unique_ptr obj (new nano::change_block (error, tree_a)); if (!error) { result = std::move (obj); @@ -1207,7 +1207,7 @@ std::shared_ptr rai::deserialize_block_json (boost::property_tree::p else if (type == "state") { bool error (false); - std::unique_ptr obj (new rai::state_block (error, tree_a)); + std::unique_ptr obj (new nano::state_block (error, tree_a)); if (!error) { result = std::move (obj); @@ -1224,67 +1224,67 @@ std::shared_ptr rai::deserialize_block_json (boost::property_tree::p return result; } -std::shared_ptr rai::deserialize_block (rai::stream & stream_a, rai::block_uniquer * uniquer_a) +std::shared_ptr nano::deserialize_block (nano::stream & stream_a, nano::block_uniquer * uniquer_a) { - rai::block_type type; + nano::block_type type; auto error (read (stream_a, type)); - std::shared_ptr result; + std::shared_ptr result; if (!error) { - result = rai::deserialize_block (stream_a, type); + result = nano::deserialize_block (stream_a, type); } return result; } -std::shared_ptr rai::deserialize_block (rai::stream & stream_a, rai::block_type type_a, rai::block_uniquer * uniquer_a) +std::shared_ptr nano::deserialize_block (nano::stream & stream_a, nano::block_type type_a, nano::block_uniquer * uniquer_a) { - std::shared_ptr result; + std::shared_ptr result; switch (type_a) { - case rai::block_type::receive: + case nano::block_type::receive: { bool error (false); - std::unique_ptr obj (new rai::receive_block (error, stream_a)); + std::unique_ptr obj (new nano::receive_block (error, stream_a)); if (!error) { result = std::move (obj); } break; } - case rai::block_type::send: + case nano::block_type::send: { bool error (false); - std::unique_ptr obj (new rai::send_block (error, stream_a)); + std::unique_ptr obj (new nano::send_block (error, stream_a)); if (!error) { result = std::move (obj); } break; } - case rai::block_type::open: + case nano::block_type::open: { bool error (false); - std::unique_ptr obj (new rai::open_block (error, stream_a)); + std::unique_ptr obj (new nano::open_block (error, stream_a)); if (!error) { result = std::move (obj); } break; } - case rai::block_type::change: + case nano::block_type::change: { bool error (false); - std::unique_ptr obj (new rai::change_block (error, stream_a)); + std::unique_ptr obj (new nano::change_block (error, stream_a)); if (!error) { result = std::move (obj); } break; } - case rai::block_type::state: + case nano::block_type::state: { bool error (false); - std::unique_ptr obj (new rai::state_block (error, stream_a)); + std::unique_ptr obj (new nano::state_block (error, stream_a)); if (!error) { result = std::move (obj); @@ -1302,18 +1302,18 @@ std::shared_ptr rai::deserialize_block (rai::stream & stream_a, rai: return result; } -void rai::receive_block::visit (rai::block_visitor & visitor_a) const +void nano::receive_block::visit (nano::block_visitor & visitor_a) const { visitor_a.receive_block (*this); } -bool rai::receive_block::operator== (rai::receive_block const & other_a) const +bool nano::receive_block::operator== (nano::receive_block const & other_a) const { auto result (hashables.previous == other_a.hashables.previous && hashables.source == other_a.hashables.source && work == other_a.work && signature == other_a.signature); return result; } -bool rai::receive_block::deserialize (rai::stream & stream_a) +bool nano::receive_block::deserialize (nano::stream & stream_a) { auto error (false); error = read (stream_a, hashables.previous.bytes); @@ -1332,7 +1332,7 @@ bool rai::receive_block::deserialize (rai::stream & stream_a) return error; } -bool rai::receive_block::deserialize_json (boost::property_tree::ptree const & tree_a) +bool nano::receive_block::deserialize_json (boost::property_tree::ptree const & tree_a) { auto error (false); try @@ -1348,7 +1348,7 @@ bool rai::receive_block::deserialize_json (boost::property_tree::ptree const & t error = hashables.source.decode_hex (source_l); if (!error) { - error = rai::from_string_hex (work_l, work); + error = nano::from_string_hex (work_l, work); if (!error) { error = signature.decode_hex (signature_l); @@ -1363,7 +1363,7 @@ bool rai::receive_block::deserialize_json (boost::property_tree::ptree const & t return error; } -void rai::receive_block::serialize (rai::stream & stream_a) const +void nano::receive_block::serialize (nano::stream & stream_a) const { write (stream_a, hashables.previous.bytes); write (stream_a, hashables.source.bytes); @@ -1371,7 +1371,7 @@ void rai::receive_block::serialize (rai::stream & stream_a) const write (stream_a, work); } -void rai::receive_block::serialize_json (std::string & string_a) const +void nano::receive_block::serialize_json (std::string & string_a) const { boost::property_tree::ptree tree; tree.put ("type", "receive"); @@ -1383,34 +1383,34 @@ void rai::receive_block::serialize_json (std::string & string_a) const tree.put ("source", source); std::string signature_l; signature.encode_hex (signature_l); - tree.put ("work", rai::to_string_hex (work)); + tree.put ("work", nano::to_string_hex (work)); tree.put ("signature", signature_l); std::stringstream ostream; boost::property_tree::write_json (ostream, tree); string_a = ostream.str (); } -rai::receive_block::receive_block (rai::block_hash const & previous_a, rai::block_hash const & source_a, rai::raw_key const & prv_a, rai::public_key const & pub_a, uint64_t work_a) : +nano::receive_block::receive_block (nano::block_hash const & previous_a, nano::block_hash const & source_a, nano::raw_key const & prv_a, nano::public_key const & pub_a, uint64_t work_a) : hashables (previous_a, source_a), -signature (rai::sign_message (prv_a, pub_a, hash ())), +signature (nano::sign_message (prv_a, pub_a, hash ())), work (work_a) { } -rai::receive_block::receive_block (bool & error_a, rai::stream & stream_a) : +nano::receive_block::receive_block (bool & error_a, nano::stream & stream_a) : hashables (error_a, stream_a) { if (!error_a) { - error_a = rai::read (stream_a, signature); + error_a = nano::read (stream_a, signature); if (!error_a) { - error_a = rai::read (stream_a, work); + error_a = nano::read (stream_a, work); } } } -rai::receive_block::receive_block (bool & error_a, boost::property_tree::ptree const & tree_a) : +nano::receive_block::receive_block (bool & error_a, boost::property_tree::ptree const & tree_a) : hashables (error_a, tree_a) { if (!error_a) @@ -1422,7 +1422,7 @@ hashables (error_a, tree_a) error_a = signature.decode_hex (signature_l); if (!error_a) { - error_a = rai::from_string_hex (work_l, work); + error_a = nano::from_string_hex (work_l, work); } } catch (std::runtime_error const &) @@ -1432,35 +1432,35 @@ hashables (error_a, tree_a) } } -void rai::receive_block::hash (blake2b_state & hash_a) const +void nano::receive_block::hash (blake2b_state & hash_a) const { hashables.hash (hash_a); } -uint64_t rai::receive_block::block_work () const +uint64_t nano::receive_block::block_work () const { return work; } -void rai::receive_block::block_work_set (uint64_t work_a) +void nano::receive_block::block_work_set (uint64_t work_a) { work = work_a; } -bool rai::receive_block::operator== (rai::block const & other_a) const +bool nano::receive_block::operator== (nano::block const & other_a) const { return blocks_equal (*this, other_a); } -bool rai::receive_block::valid_predecessor (rai::block const & block_a) const +bool nano::receive_block::valid_predecessor (nano::block const & block_a) const { bool result; switch (block_a.type ()) { - case rai::block_type::send: - case rai::block_type::receive: - case rai::block_type::open: - case rai::block_type::change: + case nano::block_type::send: + case nano::block_type::receive: + case nano::block_type::open: + case nano::block_type::change: result = true; break; default: @@ -1470,62 +1470,62 @@ bool rai::receive_block::valid_predecessor (rai::block const & block_a) const return result; } -rai::block_hash rai::receive_block::previous () const +nano::block_hash nano::receive_block::previous () const { return hashables.previous; } -rai::block_hash rai::receive_block::source () const +nano::block_hash nano::receive_block::source () const { return hashables.source; } -rai::block_hash rai::receive_block::root () const +nano::block_hash nano::receive_block::root () const { return hashables.previous; } -rai::block_hash rai::receive_block::link () const +nano::block_hash nano::receive_block::link () const { return 0; } -rai::account rai::receive_block::representative () const +nano::account nano::receive_block::representative () const { return 0; } -rai::signature rai::receive_block::block_signature () const +nano::signature nano::receive_block::block_signature () const { return signature; } -void rai::receive_block::signature_set (rai::uint512_union const & signature_a) +void nano::receive_block::signature_set (nano::uint512_union const & signature_a) { signature = signature_a; } -rai::block_type rai::receive_block::type () const +nano::block_type nano::receive_block::type () const { - return rai::block_type::receive; + return nano::block_type::receive; } -rai::receive_hashables::receive_hashables (rai::block_hash const & previous_a, rai::block_hash const & source_a) : +nano::receive_hashables::receive_hashables (nano::block_hash const & previous_a, nano::block_hash const & source_a) : previous (previous_a), source (source_a) { } -rai::receive_hashables::receive_hashables (bool & error_a, rai::stream & stream_a) +nano::receive_hashables::receive_hashables (bool & error_a, nano::stream & stream_a) { - error_a = rai::read (stream_a, previous.bytes); + error_a = nano::read (stream_a, previous.bytes); if (!error_a) { - error_a = rai::read (stream_a, source.bytes); + error_a = nano::read (stream_a, source.bytes); } } -rai::receive_hashables::receive_hashables (bool & error_a, boost::property_tree::ptree const & tree_a) +nano::receive_hashables::receive_hashables (bool & error_a, boost::property_tree::ptree const & tree_a) { try { @@ -1543,18 +1543,18 @@ rai::receive_hashables::receive_hashables (bool & error_a, boost::property_tree: } } -void rai::receive_hashables::hash (blake2b_state & hash_a) const +void nano::receive_hashables::hash (blake2b_state & hash_a) const { blake2b_update (&hash_a, previous.bytes.data (), sizeof (previous.bytes)); blake2b_update (&hash_a, source.bytes.data (), sizeof (source.bytes)); } -std::shared_ptr rai::block_uniquer::unique (std::shared_ptr block_a) +std::shared_ptr nano::block_uniquer::unique (std::shared_ptr block_a) { auto result (block_a); if (result != nullptr) { - rai::uint256_union key (block_a->full_hash ()); + nano::uint256_union key (block_a->full_hash ()); std::lock_guard lock (mutex); auto & existing (blocks[key]); if (auto block_l = existing.lock ()) @@ -1567,7 +1567,7 @@ std::shared_ptr rai::block_uniquer::unique (std::shared_ptr 0; ++i) { - auto random_offset (rai::random_pool.GenerateWord32 (0, blocks.size () - 1)); + auto random_offset (nano::random_pool.GenerateWord32 (0, blocks.size () - 1)); auto existing (std::next (blocks.begin (), random_offset)); if (existing == blocks.end ()) { @@ -1589,7 +1589,7 @@ std::shared_ptr rai::block_uniquer::unique (std::shared_ptr lock (mutex); return blocks.size (); diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp new file mode 100644 index 00000000..3deb0006 --- /dev/null +++ b/nano/lib/blocks.hpp @@ -0,0 +1,336 @@ +#pragma once + +#include + +#include +#include +#include +#include +#include + +namespace nano +{ +std::string to_string_hex (uint64_t); +bool from_string_hex (std::string const &, uint64_t &); +// We operate on streams of uint8_t by convention +using stream = std::basic_streambuf; +// Read a raw byte stream the size of `T' and fill value. +template +bool read (nano::stream & stream_a, T & value) +{ + static_assert (std::is_pod::value, "Can't stream read non-standard layout types"); + auto amount_read (stream_a.sgetn (reinterpret_cast (&value), sizeof (value))); + return amount_read != sizeof (value); +} +template +void write (nano::stream & stream_a, T const & value) +{ + static_assert (std::is_pod::value, "Can't stream write non-standard layout types"); + auto amount_written (stream_a.sputn (reinterpret_cast (&value), sizeof (value))); + assert (amount_written == sizeof (value)); +} +class block_visitor; +enum class block_type : uint8_t +{ + invalid = 0, + not_a_block = 1, + send = 2, + receive = 3, + open = 4, + change = 5, + state = 6 +}; +class block +{ +public: + // Return a digest of the hashables in this block. + nano::block_hash hash () const; + // Return a digest of hashables and non-hashables in this block. + nano::block_hash full_hash () const; + std::string to_json (); + virtual void hash (blake2b_state &) const = 0; + virtual uint64_t block_work () const = 0; + virtual void block_work_set (uint64_t) = 0; + // Previous block in account's chain, zero for open block + virtual nano::block_hash previous () const = 0; + // Source block for open/receive blocks, zero otherwise. + virtual nano::block_hash source () const = 0; + // Previous block or account number for open blocks + virtual nano::block_hash root () const = 0; + // Link field for state blocks, zero otherwise. + virtual nano::block_hash link () const = 0; + virtual nano::account representative () const = 0; + virtual void serialize (nano::stream &) const = 0; + virtual void serialize_json (std::string &) const = 0; + virtual void visit (nano::block_visitor &) const = 0; + virtual bool operator== (nano::block const &) const = 0; + virtual nano::block_type type () const = 0; + virtual nano::signature block_signature () const = 0; + virtual void signature_set (nano::uint512_union const &) = 0; + virtual ~block () = default; + virtual bool valid_predecessor (nano::block const &) const = 0; +}; +class send_hashables +{ +public: + send_hashables () = default; + send_hashables (nano::account const &, nano::block_hash const &, nano::amount const &); + send_hashables (bool &, nano::stream &); + send_hashables (bool &, boost::property_tree::ptree const &); + void hash (blake2b_state &) const; + nano::block_hash previous; + nano::account destination; + nano::amount balance; +}; +class send_block : public nano::block +{ +public: + send_block () = default; + send_block (nano::block_hash const &, nano::account const &, nano::amount const &, nano::raw_key const &, nano::public_key const &, uint64_t); + send_block (bool &, nano::stream &); + send_block (bool &, boost::property_tree::ptree const &); + virtual ~send_block () = default; + using nano::block::hash; + void hash (blake2b_state &) const override; + uint64_t block_work () const override; + void block_work_set (uint64_t) override; + nano::block_hash previous () const override; + nano::block_hash source () const override; + nano::block_hash root () const override; + nano::block_hash link () const override; + nano::account representative () const override; + void serialize (nano::stream &) const override; + void serialize_json (std::string &) const override; + bool deserialize (nano::stream &); + bool deserialize_json (boost::property_tree::ptree const &); + void visit (nano::block_visitor &) const override; + nano::block_type type () const override; + nano::signature block_signature () const override; + void signature_set (nano::uint512_union const &) override; + bool operator== (nano::block const &) const override; + bool operator== (nano::send_block const &) const; + bool valid_predecessor (nano::block const &) const override; + static size_t constexpr size = sizeof (nano::account) + sizeof (nano::block_hash) + sizeof (nano::amount) + sizeof (nano::signature) + sizeof (uint64_t); + send_hashables hashables; + nano::signature signature; + uint64_t work; +}; +class receive_hashables +{ +public: + receive_hashables () = default; + receive_hashables (nano::block_hash const &, nano::block_hash const &); + receive_hashables (bool &, nano::stream &); + receive_hashables (bool &, boost::property_tree::ptree const &); + void hash (blake2b_state &) const; + nano::block_hash previous; + nano::block_hash source; +}; +class receive_block : public nano::block +{ +public: + receive_block () = default; + receive_block (nano::block_hash const &, nano::block_hash const &, nano::raw_key const &, nano::public_key const &, uint64_t); + receive_block (bool &, nano::stream &); + receive_block (bool &, boost::property_tree::ptree const &); + virtual ~receive_block () = default; + using nano::block::hash; + void hash (blake2b_state &) const override; + uint64_t block_work () const override; + void block_work_set (uint64_t) override; + nano::block_hash previous () const override; + nano::block_hash source () const override; + nano::block_hash root () const override; + nano::block_hash link () const override; + nano::account representative () const override; + void serialize (nano::stream &) const override; + void serialize_json (std::string &) const override; + bool deserialize (nano::stream &); + bool deserialize_json (boost::property_tree::ptree const &); + void visit (nano::block_visitor &) const override; + nano::block_type type () const override; + nano::signature block_signature () const override; + void signature_set (nano::uint512_union const &) override; + bool operator== (nano::block const &) const override; + bool operator== (nano::receive_block const &) const; + bool valid_predecessor (nano::block const &) const override; + static size_t constexpr size = sizeof (nano::block_hash) + sizeof (nano::block_hash) + sizeof (nano::signature) + sizeof (uint64_t); + receive_hashables hashables; + nano::signature signature; + uint64_t work; +}; +class open_hashables +{ +public: + open_hashables () = default; + open_hashables (nano::block_hash const &, nano::account const &, nano::account const &); + open_hashables (bool &, nano::stream &); + open_hashables (bool &, boost::property_tree::ptree const &); + void hash (blake2b_state &) const; + nano::block_hash source; + nano::account representative; + nano::account account; +}; +class open_block : public nano::block +{ +public: + open_block () = default; + open_block (nano::block_hash const &, nano::account const &, nano::account const &, nano::raw_key const &, nano::public_key const &, uint64_t); + open_block (nano::block_hash const &, nano::account const &, nano::account const &, std::nullptr_t); + open_block (bool &, nano::stream &); + open_block (bool &, boost::property_tree::ptree const &); + virtual ~open_block () = default; + using nano::block::hash; + void hash (blake2b_state &) const override; + uint64_t block_work () const override; + void block_work_set (uint64_t) override; + nano::block_hash previous () const override; + nano::block_hash source () const override; + nano::block_hash root () const override; + nano::block_hash link () const override; + nano::account representative () const override; + void serialize (nano::stream &) const override; + void serialize_json (std::string &) const override; + bool deserialize (nano::stream &); + bool deserialize_json (boost::property_tree::ptree const &); + void visit (nano::block_visitor &) const override; + nano::block_type type () const override; + nano::signature block_signature () const override; + void signature_set (nano::uint512_union const &) override; + bool operator== (nano::block const &) const override; + bool operator== (nano::open_block const &) const; + bool valid_predecessor (nano::block const &) const override; + static size_t constexpr size = sizeof (nano::block_hash) + sizeof (nano::account) + sizeof (nano::account) + sizeof (nano::signature) + sizeof (uint64_t); + nano::open_hashables hashables; + nano::signature signature; + uint64_t work; +}; +class change_hashables +{ +public: + change_hashables () = default; + change_hashables (nano::block_hash const &, nano::account const &); + change_hashables (bool &, nano::stream &); + change_hashables (bool &, boost::property_tree::ptree const &); + void hash (blake2b_state &) const; + nano::block_hash previous; + nano::account representative; +}; +class change_block : public nano::block +{ +public: + change_block () = default; + change_block (nano::block_hash const &, nano::account const &, nano::raw_key const &, nano::public_key const &, uint64_t); + change_block (bool &, nano::stream &); + change_block (bool &, boost::property_tree::ptree const &); + virtual ~change_block () = default; + using nano::block::hash; + void hash (blake2b_state &) const override; + uint64_t block_work () const override; + void block_work_set (uint64_t) override; + nano::block_hash previous () const override; + nano::block_hash source () const override; + nano::block_hash root () const override; + nano::block_hash link () const override; + nano::account representative () const override; + void serialize (nano::stream &) const override; + void serialize_json (std::string &) const override; + bool deserialize (nano::stream &); + bool deserialize_json (boost::property_tree::ptree const &); + void visit (nano::block_visitor &) const override; + nano::block_type type () const override; + nano::signature block_signature () const override; + void signature_set (nano::uint512_union const &) override; + bool operator== (nano::block const &) const override; + bool operator== (nano::change_block const &) const; + bool valid_predecessor (nano::block const &) const override; + static size_t constexpr size = sizeof (nano::block_hash) + sizeof (nano::account) + sizeof (nano::signature) + sizeof (uint64_t); + nano::change_hashables hashables; + nano::signature signature; + uint64_t work; +}; +class state_hashables +{ +public: + state_hashables () = default; + state_hashables (nano::account const &, nano::block_hash const &, nano::account const &, nano::amount const &, nano::uint256_union const &); + state_hashables (bool &, nano::stream &); + state_hashables (bool &, boost::property_tree::ptree const &); + void hash (blake2b_state &) const; + // Account# / public key that operates this account + // Uses: + // Bulk signature validation in advance of further ledger processing + // Arranging uncomitted transactions by account + nano::account account; + // Previous transaction in this chain + nano::block_hash previous; + // Representative of this account + nano::account representative; + // Current balance of this account + // Allows lookup of account balance simply by looking at the head block + nano::amount balance; + // Link field contains source block_hash if receiving, destination account if sending + nano::uint256_union link; +}; +class state_block : public nano::block +{ +public: + state_block () = default; + state_block (nano::account const &, nano::block_hash const &, nano::account const &, nano::amount const &, nano::uint256_union const &, nano::raw_key const &, nano::public_key const &, uint64_t); + state_block (bool &, nano::stream &); + state_block (bool &, boost::property_tree::ptree const &); + virtual ~state_block () = default; + using nano::block::hash; + void hash (blake2b_state &) const override; + uint64_t block_work () const override; + void block_work_set (uint64_t) override; + nano::block_hash previous () const override; + nano::block_hash source () const override; + nano::block_hash root () const override; + nano::block_hash link () const override; + nano::account representative () const override; + void serialize (nano::stream &) const override; + void serialize_json (std::string &) const override; + bool deserialize (nano::stream &); + bool deserialize_json (boost::property_tree::ptree const &); + void visit (nano::block_visitor &) const override; + nano::block_type type () const override; + nano::signature block_signature () const override; + void signature_set (nano::uint512_union const &) override; + bool operator== (nano::block const &) const override; + bool operator== (nano::state_block const &) const; + bool valid_predecessor (nano::block const &) const override; + static size_t constexpr size = sizeof (nano::account) + sizeof (nano::block_hash) + sizeof (nano::account) + sizeof (nano::amount) + sizeof (nano::uint256_union) + sizeof (nano::signature) + sizeof (uint64_t); + nano::state_hashables hashables; + nano::signature signature; + uint64_t work; +}; +class block_visitor +{ +public: + virtual void send_block (nano::send_block const &) = 0; + virtual void receive_block (nano::receive_block const &) = 0; + virtual void open_block (nano::open_block const &) = 0; + virtual void change_block (nano::change_block const &) = 0; + virtual void state_block (nano::state_block const &) = 0; + virtual ~block_visitor () = default; +}; +/** + * This class serves to find and return unique variants of a block in order to minimize memory usage + */ +class block_uniquer +{ +public: + std::shared_ptr unique (std::shared_ptr); + size_t size (); + +private: + std::mutex mutex; + std::unordered_map> blocks; + static unsigned constexpr cleanup_count = 2; +}; +std::shared_ptr deserialize_block (nano::stream &, nano::block_uniquer * = nullptr); +std::shared_ptr deserialize_block (nano::stream &, nano::block_type, nano::block_uniquer * = nullptr); +std::shared_ptr deserialize_block_json (boost::property_tree::ptree const &, nano::block_uniquer * = nullptr); +void serialize_block (nano::stream &, nano::block const &); +} diff --git a/rai/lib/config.hpp b/nano/lib/config.hpp similarity index 72% rename from rai/lib/config.hpp rename to nano/lib/config.hpp index 1cef47d7..be3fd3f1 100644 --- a/rai/lib/config.hpp +++ b/nano/lib/config.hpp @@ -3,21 +3,24 @@ #include #include -namespace rai +namespace nano { /** * Network variants with different genesis blocks and network parameters * @warning Enum values are used for comparison; do not change. */ -enum class rai_networks +enum class nano_networks { // Low work parameters, publicly known genesis key, test IP ports + nano_test_network = 0, rai_test_network = 0, // Normal work parameters, secret beta genesis key, beta IP ports + nano_beta_network = 1, rai_beta_network = 1, // Normal work parameters, secret live key, live IP ports - rai_live_network = 2 + nano_live_network = 2, + rai_live_network = 2, }; -rai::rai_networks const rai_network = rai_networks::ACTIVE_NETWORK; +nano::nano_networks const nano_network = nano_networks::ACTIVE_NETWORK; std::chrono::milliseconds const transaction_timeout = std::chrono::milliseconds (1000); } diff --git a/rai/lib/errors.cpp b/nano/lib/errors.cpp similarity index 99% rename from rai/lib/errors.cpp rename to nano/lib/errors.cpp index 27ed4702..685fb121 100644 --- a/rai/lib/errors.cpp +++ b/nano/lib/errors.cpp @@ -1,4 +1,4 @@ -#include "rai/lib/errors.hpp" +#include "nano/lib/errors.hpp" std::string nano::error_common_messages::message (int ev) const { diff --git a/rai/lib/errors.hpp b/nano/lib/errors.hpp similarity index 99% rename from rai/lib/errors.hpp rename to nano/lib/errors.hpp index c947dcf5..6f53b319 100644 --- a/rai/lib/errors.hpp +++ b/nano/lib/errors.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include #include #include #include diff --git a/rai/lib/expected.hpp b/nano/lib/expected.hpp similarity index 100% rename from rai/lib/expected.hpp rename to nano/lib/expected.hpp diff --git a/rai/lib/interface.cpp b/nano/lib/interface.cpp similarity index 70% rename from rai/lib/interface.cpp rename to nano/lib/interface.cpp index b540423e..e6a3209a 100644 --- a/rai/lib/interface.cpp +++ b/nano/lib/interface.cpp @@ -1,4 +1,4 @@ -#include +#include #include @@ -8,76 +8,76 @@ #include -#include -#include -#include +#include +#include +#include #include extern "C" { void xrb_uint128_to_dec (xrb_uint128 source, char * destination) { - auto const & number (*reinterpret_cast (source)); + auto const & number (*reinterpret_cast (source)); strncpy (destination, number.to_string_dec ().c_str (), 32); } void xrb_uint256_to_string (xrb_uint256 source, char * destination) { - auto const & number (*reinterpret_cast (source)); + auto const & number (*reinterpret_cast (source)); strncpy (destination, number.to_string ().c_str (), 64); } void xrb_uint256_to_address (xrb_uint256 source, char * destination) { - auto const & number (*reinterpret_cast (source)); + auto const & number (*reinterpret_cast (source)); strncpy (destination, number.to_account ().c_str (), 65); } void xrb_uint512_to_string (xrb_uint512 source, char * destination) { - auto const & number (*reinterpret_cast (source)); + auto const & number (*reinterpret_cast (source)); strncpy (destination, number.to_string ().c_str (), 128); } int xrb_uint128_from_dec (const char * source, xrb_uint128 destination) { - auto & number (*reinterpret_cast (destination)); + auto & number (*reinterpret_cast (destination)); auto error (number.decode_dec (source)); return error ? 1 : 0; } int xrb_uint256_from_string (const char * source, xrb_uint256 destination) { - auto & number (*reinterpret_cast (destination)); + auto & number (*reinterpret_cast (destination)); auto error (number.decode_hex (source)); return error ? 1 : 0; } int xrb_uint512_from_string (const char * source, xrb_uint512 destination) { - auto & number (*reinterpret_cast (destination)); + auto & number (*reinterpret_cast (destination)); auto error (number.decode_hex (source)); return error ? 1 : 0; } int xrb_valid_address (const char * account_a) { - rai::uint256_union account; + nano::uint256_union account; auto error (account.decode_account (account_a)); return error ? 1 : 0; } void xrb_generate_random (xrb_uint256 seed) { - auto & number (*reinterpret_cast (seed)); - rai::random_pool.GenerateBlock (number.bytes.data (), number.bytes.size ()); + auto & number (*reinterpret_cast (seed)); + nano::random_pool.GenerateBlock (number.bytes.data (), number.bytes.size ()); } void xrb_seed_key (xrb_uint256 seed, int index, xrb_uint256 destination) { - auto & seed_l (*reinterpret_cast (seed)); - auto & destination_l (*reinterpret_cast (destination)); - rai::deterministic_key (seed_l, index, destination_l); + auto & seed_l (*reinterpret_cast (seed)); + auto & destination_l (*reinterpret_cast (destination)); + nano::deterministic_key (seed_l, index, destination_l); } void xrb_key_account (const xrb_uint256 key, xrb_uint256 pub) @@ -94,14 +94,14 @@ char * xrb_sign_transaction (const char * transaction, const xrb_uint256 private std::string transaction_l (transaction); std::stringstream block_stream (transaction_l); boost::property_tree::read_json (block_stream, block_l); - auto block (rai::deserialize_block_json (block_l)); + auto block (nano::deserialize_block_json (block_l)); if (block != nullptr) { - rai::uint256_union pub; + nano::uint256_union pub; ed25519_publickey (private_key, pub.bytes.data ()); - rai::raw_key prv; - prv.data = *reinterpret_cast (private_key); - block->signature_set (rai::sign_message (prv, pub, block->hash ())); + nano::raw_key prv; + prv.data = *reinterpret_cast (private_key); + block->signature_set (nano::sign_message (prv, pub, block->hash ())); auto json (block->to_json ()); result = reinterpret_cast (malloc (json.size () + 1)); strncpy (result, json.c_str (), json.size () + 1); @@ -122,10 +122,10 @@ char * xrb_work_transaction (const char * transaction) std::string transaction_l (transaction); std::stringstream block_stream (transaction_l); boost::property_tree::read_json (block_stream, block_l); - auto block (rai::deserialize_block_json (block_l)); + auto block (nano::deserialize_block_json (block_l)); if (block != nullptr) { - rai::work_pool pool (boost::thread::hardware_concurrency ()); + nano::work_pool pool (boost::thread::hardware_concurrency ()); auto work (pool.generate (block->root ())); block->block_work_set (work); auto json (block->to_json ()); @@ -142,7 +142,7 @@ char * xrb_work_transaction (const char * transaction) #include void ed25519_randombytes_unsafe (void * out, size_t outlen) { - rai::random_pool.GenerateBlock (reinterpret_cast (out), outlen); + nano::random_pool.GenerateBlock (reinterpret_cast (out), outlen); } void ed25519_hash_init (ed25519_hash_context * ctx) { diff --git a/rai/lib/interface.h b/nano/lib/interface.h similarity index 100% rename from rai/lib/interface.h rename to nano/lib/interface.h diff --git a/rai/lib/numbers.cpp b/nano/lib/numbers.cpp similarity index 68% rename from rai/lib/numbers.cpp rename to nano/lib/numbers.cpp index 9f7259eb..3eb53787 100644 --- a/rai/lib/numbers.cpp +++ b/nano/lib/numbers.cpp @@ -1,5 +1,5 @@ -#include -#include +#include +#include #include @@ -8,7 +8,7 @@ #include #include -thread_local CryptoPP::AutoSeededRandomPool rai::random_pool; +thread_local CryptoPP::AutoSeededRandomPool nano::random_pool; namespace { @@ -41,7 +41,7 @@ uint8_t account_decode (char value) } } -void rai::uint256_union::encode_account (std::string & destination_a) const +void nano::uint256_union::encode_account (std::string & destination_a) const { assert (destination_a.empty ()); destination_a.reserve (64); @@ -50,9 +50,9 @@ void rai::uint256_union::encode_account (std::string & destination_a) const blake2b_init (&hash, 5); blake2b_update (&hash, bytes.data (), bytes.size ()); blake2b_final (&hash, reinterpret_cast (&check), 5); - rai::uint512_t number_l (number ()); + nano::uint512_t number_l (number ()); number_l <<= 40; - number_l |= rai::uint512_t (check); + number_l |= nano::uint512_t (check); for (auto i (0); i < 60; ++i) { uint8_t r (number_l & static_cast (0x1f)); @@ -63,14 +63,14 @@ void rai::uint256_union::encode_account (std::string & destination_a) const std::reverse (destination_a.begin (), destination_a.end ()); } -std::string rai::uint256_union::to_account () const +std::string nano::uint256_union::to_account () const { std::string result; encode_account (result); return result; } -bool rai::uint256_union::decode_account (std::string const & source_a) +bool nano::uint256_union::decode_account (std::string const & source_a) { auto error (source_a.size () < 5); if (!error) @@ -85,7 +85,7 @@ bool rai::uint256_union::decode_account (std::string const & source_a) auto i (source_a.begin () + (xrb_prefix ? 4 : 5)); if (*i == '1' || *i == '3') { - rai::uint512_t number_l; + nano::uint512_t number_l; for (auto j (source_a.end ()); !error && i != j; ++i) { uint8_t character (*i); @@ -103,7 +103,7 @@ bool rai::uint256_union::decode_account (std::string const & source_a) } if (!error) { - *this = (number_l >> 40).convert_to (); + *this = (number_l >> 40).convert_to (); uint64_t check (number_l & static_cast (0xffffffffff)); uint64_t validation (0); blake2b_state hash; @@ -127,43 +127,43 @@ bool rai::uint256_union::decode_account (std::string const & source_a) return error; } -rai::uint256_union::uint256_union (rai::uint256_t const & number_a) +nano::uint256_union::uint256_union (nano::uint256_t const & number_a) { bytes.fill (0); boost::multiprecision::export_bits (number_a, bytes.rbegin (), 8, false); } -bool rai::uint256_union::operator== (rai::uint256_union const & other_a) const +bool nano::uint256_union::operator== (nano::uint256_union const & other_a) const { return bytes == other_a.bytes; } // Construct a uint256_union = AES_ENC_CTR (cleartext, key, iv) -void rai::uint256_union::encrypt (rai::raw_key const & cleartext, rai::raw_key const & key, uint128_union const & iv) +void nano::uint256_union::encrypt (nano::raw_key const & cleartext, nano::raw_key const & key, uint128_union const & iv) { CryptoPP::AES::Encryption alg (key.data.bytes.data (), sizeof (key.data.bytes)); CryptoPP::CTR_Mode_ExternalCipher::Encryption enc (alg, iv.bytes.data ()); enc.ProcessData (bytes.data (), cleartext.data.bytes.data (), sizeof (cleartext.data.bytes)); } -bool rai::uint256_union::is_zero () const +bool nano::uint256_union::is_zero () const { return qwords[0] == 0 && qwords[1] == 0 && qwords[2] == 0 && qwords[3] == 0; } -std::string rai::uint256_union::to_string () const +std::string nano::uint256_union::to_string () const { std::string result; encode_hex (result); return result; } -bool rai::uint256_union::operator< (rai::uint256_union const & other_a) const +bool nano::uint256_union::operator< (nano::uint256_union const & other_a) const { return std::memcmp (bytes.data (), other_a.bytes.data (), 32) < 0; } -rai::uint256_union & rai::uint256_union::operator^= (rai::uint256_union const & other_a) +nano::uint256_union & nano::uint256_union::operator^= (nano::uint256_union const & other_a) { auto j (other_a.qwords.begin ()); for (auto i (qwords.begin ()), n (qwords.end ()); i != n; ++i, ++j) @@ -173,9 +173,9 @@ rai::uint256_union & rai::uint256_union::operator^= (rai::uint256_union const & return *this; } -rai::uint256_union rai::uint256_union::operator^ (rai::uint256_union const & other_a) const +nano::uint256_union nano::uint256_union::operator^ (nano::uint256_union const & other_a) const { - rai::uint256_union result; + nano::uint256_union result; auto k (result.qwords.begin ()); for (auto i (qwords.begin ()), j (other_a.qwords.begin ()), n (qwords.end ()); i != n; ++i, ++j, ++k) { @@ -184,26 +184,26 @@ rai::uint256_union rai::uint256_union::operator^ (rai::uint256_union const & oth return result; } -rai::uint256_union::uint256_union (std::string const & hex_a) +nano::uint256_union::uint256_union (std::string const & hex_a) { auto error (decode_hex (hex_a)); release_assert (!error); } -void rai::uint256_union::clear () +void nano::uint256_union::clear () { qwords.fill (0); } -rai::uint256_t rai::uint256_union::number () const +nano::uint256_t nano::uint256_union::number () const { - rai::uint256_t result; + nano::uint256_t result; boost::multiprecision::import_bits (result, bytes.begin (), bytes.end (), false); return result; } -void rai::uint256_union::encode_hex (std::string & text) const +void nano::uint256_union::encode_hex (std::string & text) const { assert (text.empty ()); std::stringstream stream; @@ -212,14 +212,14 @@ void rai::uint256_union::encode_hex (std::string & text) const text = stream.str (); } -bool rai::uint256_union::decode_hex (std::string const & text) +bool nano::uint256_union::decode_hex (std::string const & text) { auto error (false); if (!text.empty () && text.size () <= 64) { std::stringstream stream (text); stream << std::hex << std::noshowbase; - rai::uint256_t number_l; + nano::uint256_t number_l; try { stream >> number_l; @@ -241,7 +241,7 @@ bool rai::uint256_union::decode_hex (std::string const & text) return error; } -void rai::uint256_union::encode_dec (std::string & text) const +void nano::uint256_union::encode_dec (std::string & text) const { assert (text.empty ()); std::stringstream stream; @@ -250,14 +250,14 @@ void rai::uint256_union::encode_dec (std::string & text) const text = stream.str (); } -bool rai::uint256_union::decode_dec (std::string const & text) +bool nano::uint256_union::decode_dec (std::string const & text) { auto error (text.size () > 78 || (text.size () > 1 && text[0] == '0') || (text.size () > 0 && text[0] == '-')); if (!error) { std::stringstream stream (text); stream << std::dec << std::noshowbase; - rai::uint256_t number_l; + nano::uint256_t number_l; try { stream >> number_l; @@ -275,46 +275,46 @@ bool rai::uint256_union::decode_dec (std::string const & text) return error; } -rai::uint256_union::uint256_union (uint64_t value0) +nano::uint256_union::uint256_union (uint64_t value0) { - *this = rai::uint256_t (value0); + *this = nano::uint256_t (value0); } -bool rai::uint256_union::operator!= (rai::uint256_union const & other_a) const +bool nano::uint256_union::operator!= (nano::uint256_union const & other_a) const { return !(*this == other_a); } -bool rai::uint512_union::operator== (rai::uint512_union const & other_a) const +bool nano::uint512_union::operator== (nano::uint512_union const & other_a) const { return bytes == other_a.bytes; } -rai::uint512_union::uint512_union (rai::uint512_t const & number_a) +nano::uint512_union::uint512_union (nano::uint512_t const & number_a) { bytes.fill (0); boost::multiprecision::export_bits (number_a, bytes.rbegin (), 8, false); } -bool rai::uint512_union::is_zero () const +bool nano::uint512_union::is_zero () const { return qwords[0] == 0 && qwords[1] == 0 && qwords[2] == 0 && qwords[3] == 0 && qwords[4] == 0 && qwords[5] == 0 && qwords[6] == 0 && qwords[7] == 0; } -void rai::uint512_union::clear () +void nano::uint512_union::clear () { bytes.fill (0); } -rai::uint512_t rai::uint512_union::number () const +nano::uint512_t nano::uint512_union::number () const { - rai::uint512_t result; + nano::uint512_t result; boost::multiprecision::import_bits (result, bytes.begin (), bytes.end (), false); return result; } -void rai::uint512_union::encode_hex (std::string & text) const +void nano::uint512_union::encode_hex (std::string & text) const { assert (text.empty ()); std::stringstream stream; @@ -323,14 +323,14 @@ void rai::uint512_union::encode_hex (std::string & text) const text = stream.str (); } -bool rai::uint512_union::decode_hex (std::string const & text) +bool nano::uint512_union::decode_hex (std::string const & text) { auto error (text.size () > 128); if (!error) { std::stringstream stream (text); stream << std::hex << std::noshowbase; - rai::uint512_t number_l; + nano::uint512_t number_l; try { stream >> number_l; @@ -348,130 +348,130 @@ bool rai::uint512_union::decode_hex (std::string const & text) return error; } -bool rai::uint512_union::operator!= (rai::uint512_union const & other_a) const +bool nano::uint512_union::operator!= (nano::uint512_union const & other_a) const { return !(*this == other_a); } -rai::uint512_union & rai::uint512_union::operator^= (rai::uint512_union const & other_a) +nano::uint512_union & nano::uint512_union::operator^= (nano::uint512_union const & other_a) { uint256s[0] ^= other_a.uint256s[0]; uint256s[1] ^= other_a.uint256s[1]; return *this; } -std::string rai::uint512_union::to_string () const +std::string nano::uint512_union::to_string () const { std::string result; encode_hex (result); return result; } -rai::raw_key::~raw_key () +nano::raw_key::~raw_key () { data.clear (); } -bool rai::raw_key::operator== (rai::raw_key const & other_a) const +bool nano::raw_key::operator== (nano::raw_key const & other_a) const { return data == other_a.data; } -bool rai::raw_key::operator!= (rai::raw_key const & other_a) const +bool nano::raw_key::operator!= (nano::raw_key const & other_a) const { return !(*this == other_a); } // This this = AES_DEC_CTR (ciphertext, key, iv) -void rai::raw_key::decrypt (rai::uint256_union const & ciphertext, rai::raw_key const & key_a, uint128_union const & iv) +void nano::raw_key::decrypt (nano::uint256_union const & ciphertext, nano::raw_key const & key_a, uint128_union const & iv) { CryptoPP::AES::Encryption alg (key_a.data.bytes.data (), sizeof (key_a.data.bytes)); CryptoPP::CTR_Mode_ExternalCipher::Decryption dec (alg, iv.bytes.data ()); dec.ProcessData (data.bytes.data (), ciphertext.bytes.data (), sizeof (ciphertext.bytes)); } -rai::uint512_union rai::sign_message (rai::raw_key const & private_key, rai::public_key const & public_key, rai::uint256_union const & message) +nano::uint512_union nano::sign_message (nano::raw_key const & private_key, nano::public_key const & public_key, nano::uint256_union const & message) { - rai::uint512_union result; + nano::uint512_union result; ed25519_sign (message.bytes.data (), sizeof (message.bytes), private_key.data.bytes.data (), public_key.bytes.data (), result.bytes.data ()); return result; } -void rai::deterministic_key (rai::uint256_union const & seed_a, uint32_t index_a, rai::uint256_union & prv_a) +void nano::deterministic_key (nano::uint256_union const & seed_a, uint32_t index_a, nano::uint256_union & prv_a) { blake2b_state hash; blake2b_init (&hash, prv_a.bytes.size ()); blake2b_update (&hash, seed_a.bytes.data (), seed_a.bytes.size ()); - rai::uint256_union index (index_a); + nano::uint256_union index (index_a); blake2b_update (&hash, reinterpret_cast (&index.dwords[7]), sizeof (uint32_t)); blake2b_final (&hash, prv_a.bytes.data (), prv_a.bytes.size ()); } -rai::public_key rai::pub_key (rai::private_key const & privatekey_a) +nano::public_key nano::pub_key (nano::private_key const & privatekey_a) { - rai::uint256_union result; + nano::uint256_union result; ed25519_publickey (privatekey_a.bytes.data (), result.bytes.data ()); return result; } -bool rai::validate_message (rai::public_key const & public_key, rai::uint256_union const & message, rai::uint512_union const & signature) +bool nano::validate_message (nano::public_key const & public_key, nano::uint256_union const & message, nano::uint512_union const & signature) { auto result (0 != ed25519_sign_open (message.bytes.data (), sizeof (message.bytes), public_key.bytes.data (), signature.bytes.data ())); return result; } -bool rai::validate_message_batch (const unsigned char ** m, size_t * mlen, const unsigned char ** pk, const unsigned char ** RS, size_t num, int * valid) +bool nano::validate_message_batch (const unsigned char ** m, size_t * mlen, const unsigned char ** pk, const unsigned char ** RS, size_t num, int * valid) { bool result (0 == ed25519_sign_open_batch (m, mlen, pk, RS, num, valid)); return result; } -rai::uint128_union::uint128_union (std::string const & string_a) +nano::uint128_union::uint128_union (std::string const & string_a) { auto error (decode_hex (string_a)); release_assert (!error); } -rai::uint128_union::uint128_union (uint64_t value_a) +nano::uint128_union::uint128_union (uint64_t value_a) { - *this = rai::uint128_t (value_a); + *this = nano::uint128_t (value_a); } -rai::uint128_union::uint128_union (rai::uint128_t const & number_a) +nano::uint128_union::uint128_union (nano::uint128_t const & number_a) { bytes.fill (0); boost::multiprecision::export_bits (number_a, bytes.rbegin (), 8, false); } -bool rai::uint128_union::operator== (rai::uint128_union const & other_a) const +bool nano::uint128_union::operator== (nano::uint128_union const & other_a) const { return qwords[0] == other_a.qwords[0] && qwords[1] == other_a.qwords[1]; } -bool rai::uint128_union::operator!= (rai::uint128_union const & other_a) const +bool nano::uint128_union::operator!= (nano::uint128_union const & other_a) const { return !(*this == other_a); } -bool rai::uint128_union::operator< (rai::uint128_union const & other_a) const +bool nano::uint128_union::operator< (nano::uint128_union const & other_a) const { return std::memcmp (bytes.data (), other_a.bytes.data (), 16) < 0; } -bool rai::uint128_union::operator> (rai::uint128_union const & other_a) const +bool nano::uint128_union::operator> (nano::uint128_union const & other_a) const { return std::memcmp (bytes.data (), other_a.bytes.data (), 16) > 0; } -rai::uint128_t rai::uint128_union::number () const +nano::uint128_t nano::uint128_union::number () const { - rai::uint128_t result; + nano::uint128_t result; boost::multiprecision::import_bits (result, bytes.begin (), bytes.end (), false); return result; } -void rai::uint128_union::encode_hex (std::string & text) const +void nano::uint128_union::encode_hex (std::string & text) const { assert (text.empty ()); std::stringstream stream; @@ -480,14 +480,14 @@ void rai::uint128_union::encode_hex (std::string & text) const text = stream.str (); } -bool rai::uint128_union::decode_hex (std::string const & text) +bool nano::uint128_union::decode_hex (std::string const & text) { auto error (text.size () > 32); if (!error) { std::stringstream stream (text); stream << std::hex << std::noshowbase; - rai::uint128_t number_l; + nano::uint128_t number_l; try { stream >> number_l; @@ -505,7 +505,7 @@ bool rai::uint128_union::decode_hex (std::string const & text) return error; } -void rai::uint128_union::encode_dec (std::string & text) const +void nano::uint128_union::encode_dec (std::string & text) const { assert (text.empty ()); std::stringstream stream; @@ -514,7 +514,7 @@ void rai::uint128_union::encode_dec (std::string & text) const text = stream.str (); } -bool rai::uint128_union::decode_dec (std::string const & text) +bool nano::uint128_union::decode_dec (std::string const & text) { auto error (text.size () > 39 || (text.size () > 1 && text[0] == '0') || (text.size () > 0 && text[0] == '-')); if (!error) @@ -525,7 +525,7 @@ bool rai::uint128_union::decode_dec (std::string const & text) try { stream >> number_l; - rai::uint128_t unchecked (number_l); + nano::uint128_t unchecked (number_l); *this = unchecked; if (!stream.eof ()) { @@ -540,7 +540,7 @@ bool rai::uint128_union::decode_dec (std::string const & text) return error; } -void format_frac (std::ostringstream & stream, rai::uint128_t value, rai::uint128_t scale, int precision) +void format_frac (std::ostringstream & stream, nano::uint128_t value, nano::uint128_t scale, int precision) { auto reduce = scale; auto rem = value; @@ -554,9 +554,9 @@ void format_frac (std::ostringstream & stream, rai::uint128_t value, rai::uint12 } } -void format_dec (std::ostringstream & stream, rai::uint128_t value, char group_sep, const std::string & groupings) +void format_dec (std::ostringstream & stream, nano::uint128_t value, char group_sep, const std::string & groupings) { - auto largestPow10 = rai::uint256_t (1); + auto largestPow10 = nano::uint256_t (1); int dec_count = 1; while (1) { @@ -597,8 +597,8 @@ void format_dec (std::ostringstream & stream, rai::uint128_t value, char group_s } } - auto reduce = rai::uint128_t (largestPow10); - rai::uint128_t rem = value; + auto reduce = nano::uint128_t (largestPow10); + nano::uint128_t rem = value; while (reduce > 0) { auto val = rem / reduce; @@ -613,7 +613,7 @@ void format_dec (std::ostringstream & stream, rai::uint128_t value, char group_s } } -std::string format_balance (rai::uint128_t balance, rai::uint128_t scale, int precision, bool group_digits, char thousands_sep, char decimal_point, std::string & grouping) +std::string format_balance (nano::uint128_t balance, nano::uint128_t scale, int precision, bool group_digits, char thousands_sep, char decimal_point, std::string & grouping) { std::ostringstream stream; auto int_part = balance / scale; @@ -650,7 +650,7 @@ std::string format_balance (rai::uint128_t balance, rai::uint128_t scale, int pr return stream.str (); } -std::string rai::uint128_union::format_balance (rai::uint128_t scale, int precision, bool group_digits) +std::string nano::uint128_union::format_balance (nano::uint128_t scale, int precision, bool group_digits) { auto thousands_sep = std::use_facet> (std::locale ()).thousands_sep (); auto decimal_point = std::use_facet> (std::locale ()).decimal_point (); @@ -658,7 +658,7 @@ std::string rai::uint128_union::format_balance (rai::uint128_t scale, int precis return ::format_balance (number (), scale, precision, group_digits, thousands_sep, decimal_point, grouping); } -std::string rai::uint128_union::format_balance (rai::uint128_t scale, int precision, bool group_digits, const std::locale & locale) +std::string nano::uint128_union::format_balance (nano::uint128_t scale, int precision, bool group_digits, const std::locale & locale) { auto thousands_sep = std::use_facet> (locale).thousands_sep (); auto decimal_point = std::use_facet> (locale).decimal_point (); @@ -666,24 +666,24 @@ std::string rai::uint128_union::format_balance (rai::uint128_t scale, int precis return ::format_balance (number (), scale, precision, group_digits, thousands_sep, decimal_point, grouping); } -void rai::uint128_union::clear () +void nano::uint128_union::clear () { qwords.fill (0); } -bool rai::uint128_union::is_zero () const +bool nano::uint128_union::is_zero () const { return qwords[0] == 0 && qwords[1] == 0; } -std::string rai::uint128_union::to_string () const +std::string nano::uint128_union::to_string () const { std::string result; encode_hex (result); return result; } -std::string rai::uint128_union::to_string_dec () const +std::string nano::uint128_union::to_string_dec () const { std::string result; encode_dec (result); diff --git a/rai/lib/numbers.hpp b/nano/lib/numbers.hpp similarity index 52% rename from rai/lib/numbers.hpp rename to nano/lib/numbers.hpp index 0fa38e42..605a1112 100644 --- a/rai/lib/numbers.hpp +++ b/nano/lib/numbers.hpp @@ -4,21 +4,21 @@ #include -namespace rai +namespace nano { -// Random pool used by RaiBlocks. +// Random pool used by Nano. // This must be thread_local as long as the AutoSeededRandomPool implementation requires it extern thread_local CryptoPP::AutoSeededRandomPool random_pool; using uint128_t = boost::multiprecision::uint128_t; using uint256_t = boost::multiprecision::uint256_t; using uint512_t = boost::multiprecision::uint512_t; // SI dividers -rai::uint128_t const Gxrb_ratio = rai::uint128_t ("1000000000000000000000000000000000"); // 10^33 -rai::uint128_t const Mxrb_ratio = rai::uint128_t ("1000000000000000000000000000000"); // 10^30 -rai::uint128_t const kxrb_ratio = rai::uint128_t ("1000000000000000000000000000"); // 10^27 -rai::uint128_t const xrb_ratio = rai::uint128_t ("1000000000000000000000000"); // 10^24 -rai::uint128_t const mxrb_ratio = rai::uint128_t ("1000000000000000000000"); // 10^21 -rai::uint128_t const uxrb_ratio = rai::uint128_t ("1000000000000000000"); // 10^18 +nano::uint128_t const Gxrb_ratio = nano::uint128_t ("1000000000000000000000000000000000"); // 10^33 +nano::uint128_t const Mxrb_ratio = nano::uint128_t ("1000000000000000000000000000000"); // 10^30 +nano::uint128_t const kxrb_ratio = nano::uint128_t ("1000000000000000000000000000"); // 10^27 +nano::uint128_t const xrb_ratio = nano::uint128_t ("1000000000000000000000000"); // 10^24 +nano::uint128_t const mxrb_ratio = nano::uint128_t ("1000000000000000000000"); // 10^21 +nano::uint128_t const uxrb_ratio = nano::uint128_t ("1000000000000000000"); // 10^18 union uint128_union { @@ -30,19 +30,19 @@ public: */ uint128_union (std::string const &); uint128_union (uint64_t); - uint128_union (rai::uint128_union const &) = default; - uint128_union (rai::uint128_t const &); - bool operator== (rai::uint128_union const &) const; - bool operator!= (rai::uint128_union const &) const; - bool operator< (rai::uint128_union const &) const; - bool operator> (rai::uint128_union const &) const; + uint128_union (nano::uint128_union const &) = default; + uint128_union (nano::uint128_t const &); + bool operator== (nano::uint128_union const &) const; + bool operator!= (nano::uint128_union const &) const; + bool operator< (nano::uint128_union const &) const; + bool operator> (nano::uint128_union const &) const; void encode_hex (std::string &) const; bool decode_hex (std::string const &); void encode_dec (std::string &) const; bool decode_dec (std::string const &); - std::string format_balance (rai::uint128_t scale, int precision, bool group_digits); - std::string format_balance (rai::uint128_t scale, int precision, bool group_digits, const std::locale & locale); - rai::uint128_t number () const; + std::string format_balance (nano::uint128_t scale, int precision, bool group_digits); + std::string format_balance (nano::uint128_t scale, int precision, bool group_digits, const std::locale & locale); + nano::uint128_t number () const; void clear (); bool is_zero () const; std::string to_string () const; @@ -64,13 +64,13 @@ union uint256_union */ uint256_union (std::string const &); uint256_union (uint64_t); - uint256_union (rai::uint256_t const &); - void encrypt (rai::raw_key const &, rai::raw_key const &, uint128_union const &); - uint256_union & operator^= (rai::uint256_union const &); - uint256_union operator^ (rai::uint256_union const &) const; - bool operator== (rai::uint256_union const &) const; - bool operator!= (rai::uint256_union const &) const; - bool operator< (rai::uint256_union const &) const; + uint256_union (nano::uint256_t const &); + void encrypt (nano::raw_key const &, nano::raw_key const &, uint128_union const &); + uint256_union & operator^= (nano::uint256_union const &); + uint256_union operator^ (nano::uint256_union const &) const; + bool operator== (nano::uint256_union const &) const; + bool operator!= (nano::uint256_union const &) const; + bool operator< (nano::uint256_union const &) const; void encode_hex (std::string &) const; bool decode_hex (std::string const &); void encode_dec (std::string &) const; @@ -86,7 +86,7 @@ union uint256_union void clear (); bool is_zero () const; std::string to_string () const; - rai::uint256_t number () const; + nano::uint256_t number () const; }; // All keys and hashes are 256 bit. using block_hash = uint256_union; @@ -100,18 +100,18 @@ class raw_key public: raw_key () = default; ~raw_key (); - void decrypt (rai::uint256_union const &, rai::raw_key const &, uint128_union const &); - bool operator== (rai::raw_key const &) const; - bool operator!= (rai::raw_key const &) const; - rai::uint256_union data; + void decrypt (nano::uint256_union const &, nano::raw_key const &, uint128_union const &); + bool operator== (nano::raw_key const &) const; + bool operator!= (nano::raw_key const &) const; + nano::uint256_union data; }; union uint512_union { uint512_union () = default; - uint512_union (rai::uint512_t const &); - bool operator== (rai::uint512_union const &) const; - bool operator!= (rai::uint512_union const &) const; - rai::uint512_union & operator^= (rai::uint512_union const &); + uint512_union (nano::uint512_t const &); + bool operator== (nano::uint512_union const &) const; + bool operator!= (nano::uint512_union const &) const; + nano::uint512_union & operator^= (nano::uint512_union const &); void encode_hex (std::string &) const; bool decode_hex (std::string const &); std::array bytes; @@ -120,33 +120,33 @@ union uint512_union std::array uint256s; void clear (); bool is_zero () const; - rai::uint512_t number () const; + nano::uint512_t number () const; std::string to_string () const; }; // Only signatures are 512 bit. using signature = uint512_union; -rai::uint512_union sign_message (rai::raw_key const &, rai::public_key const &, rai::uint256_union const &); -bool validate_message (rai::public_key const &, rai::uint256_union const &, rai::uint512_union const &); +nano::uint512_union sign_message (nano::raw_key const &, nano::public_key const &, nano::uint256_union const &); +bool validate_message (nano::public_key const &, nano::uint256_union const &, nano::uint512_union const &); bool validate_message_batch (const unsigned char **, size_t *, const unsigned char **, const unsigned char **, size_t, int *); -void deterministic_key (rai::uint256_union const &, uint32_t, rai::uint256_union &); -rai::public_key pub_key (rai::private_key const &); +void deterministic_key (nano::uint256_union const &, uint32_t, nano::uint256_union &); +nano::public_key pub_key (nano::private_key const &); } namespace std { template <> -struct hash +struct hash<::nano::uint256_union> { - size_t operator() (rai::uint256_union const & data_a) const + size_t operator() (::nano::uint256_union const & data_a) const { return *reinterpret_cast (data_a.bytes.data ()); } }; template <> -struct hash +struct hash<::nano::uint256_t> { - size_t operator() (rai::uint256_t const & number_a) const + size_t operator() (::nano::uint256_t const & number_a) const { return number_a.convert_to (); } diff --git a/nano/lib/plat/darwin/thread_role.cpp b/nano/lib/plat/darwin/thread_role.cpp new file mode 100644 index 00000000..6ee3b639 --- /dev/null +++ b/nano/lib/plat/darwin/thread_role.cpp @@ -0,0 +1,7 @@ +#include +#include + +void nano::thread_role::set_name (std::string thread_name) +{ + pthread_setname_np (thread_name.c_str ()); +} diff --git a/nano/lib/plat/default/priority.cpp b/nano/lib/plat/default/priority.cpp new file mode 100644 index 00000000..47d6a1d5 --- /dev/null +++ b/nano/lib/plat/default/priority.cpp @@ -0,0 +1,5 @@ +#include + +void nano::work_thread_reprioritize () +{ +} diff --git a/rai/lib/plat/freebsd/thread_role.cpp b/nano/lib/plat/freebsd/thread_role.cpp similarity index 55% rename from rai/lib/plat/freebsd/thread_role.cpp rename to nano/lib/plat/freebsd/thread_role.cpp index 870f9832..7dc4c8c6 100644 --- a/rai/lib/plat/freebsd/thread_role.cpp +++ b/nano/lib/plat/freebsd/thread_role.cpp @@ -1,8 +1,8 @@ +#include #include #include -#include -void rai::thread_role::set_name (std::string thread_name) +void nano::thread_role::set_name (std::string thread_name) { pthread_set_name_np (pthread_self (), thread_name.c_str ()); } diff --git a/rai/lib/plat/linux/priority.cpp b/nano/lib/plat/linux/priority.cpp similarity index 79% rename from rai/lib/plat/linux/priority.cpp rename to nano/lib/plat/linux/priority.cpp index 56ba2ddf..e380523f 100644 --- a/rai/lib/plat/linux/priority.cpp +++ b/nano/lib/plat/linux/priority.cpp @@ -1,8 +1,8 @@ -#include +#include #include -void rai::work_thread_reprioritize () +void nano::work_thread_reprioritize () { auto handle (pthread_self ()); int policy; diff --git a/nano/lib/plat/linux/thread_role.cpp b/nano/lib/plat/linux/thread_role.cpp new file mode 100644 index 00000000..e8d254ea --- /dev/null +++ b/nano/lib/plat/linux/thread_role.cpp @@ -0,0 +1,7 @@ +#include +#include + +void nano::thread_role::set_name (std::string thread_name) +{ + pthread_setname_np (pthread_self (), thread_name.c_str ()); +} diff --git a/rai/lib/plat/posix/perms.cpp b/nano/lib/plat/posix/perms.cpp similarity index 54% rename from rai/lib/plat/posix/perms.cpp rename to nano/lib/plat/posix/perms.cpp index e34b8aa1..d26bdd60 100644 --- a/rai/lib/plat/posix/perms.cpp +++ b/nano/lib/plat/posix/perms.cpp @@ -1,31 +1,31 @@ #include -#include +#include #include #include -void rai::set_umask () +void nano::set_umask () { umask (077); } -void rai::set_secure_perm_directory (boost::filesystem::path const & path) +void nano::set_secure_perm_directory (boost::filesystem::path const & path) { boost::filesystem::permissions (path, boost::filesystem::owner_all); } -void rai::set_secure_perm_directory (boost::filesystem::path const & path, boost::system::error_code & ec) +void nano::set_secure_perm_directory (boost::filesystem::path const & path, boost::system::error_code & ec) { boost::filesystem::permissions (path, boost::filesystem::owner_all, ec); } -void rai::set_secure_perm_file (boost::filesystem::path const & path) +void nano::set_secure_perm_file (boost::filesystem::path const & path) { boost::filesystem::permissions (path, boost::filesystem::perms::owner_read | boost::filesystem::perms::owner_write); } -void rai::set_secure_perm_file (boost::filesystem::path const & path, boost::system::error_code & ec) +void nano::set_secure_perm_file (boost::filesystem::path const & path, boost::system::error_code & ec) { boost::filesystem::permissions (path, boost::filesystem::perms::owner_read | boost::filesystem::perms::owner_write, ec); } diff --git a/rai/lib/plat/windows/perms.cpp b/nano/lib/plat/windows/perms.cpp similarity index 58% rename from rai/lib/plat/windows/perms.cpp rename to nano/lib/plat/windows/perms.cpp index 72c2dfb6..90a7576f 100644 --- a/rai/lib/plat/windows/perms.cpp +++ b/nano/lib/plat/windows/perms.cpp @@ -1,12 +1,12 @@ #include #include -#include +#include #include #include #include -void rai::set_umask () +void nano::set_umask () { int oldMode; @@ -14,22 +14,22 @@ void rai::set_umask () assert (result == 0); } -void rai::set_secure_perm_directory (boost::filesystem::path const & path) +void nano::set_secure_perm_directory (boost::filesystem::path const & path) { boost::filesystem::permissions (path, boost::filesystem::owner_all); } -void rai::set_secure_perm_directory (boost::filesystem::path const & path, boost::system::error_code & ec) +void nano::set_secure_perm_directory (boost::filesystem::path const & path, boost::system::error_code & ec) { boost::filesystem::permissions (path, boost::filesystem::owner_all, ec); } -void rai::set_secure_perm_file (boost::filesystem::path const & path) +void nano::set_secure_perm_file (boost::filesystem::path const & path) { boost::filesystem::permissions (path, boost::filesystem::owner_read | boost::filesystem::owner_write); } -void rai::set_secure_perm_file (boost::filesystem::path const & path, boost::system::error_code & ec) +void nano::set_secure_perm_file (boost::filesystem::path const & path, boost::system::error_code & ec) { boost::filesystem::permissions (path, boost::filesystem::owner_read | boost::filesystem::owner_write, ec); } diff --git a/rai/lib/plat/windows/priority.cpp b/nano/lib/plat/windows/priority.cpp similarity index 61% rename from rai/lib/plat/windows/priority.cpp rename to nano/lib/plat/windows/priority.cpp index 140cdf32..d081e9c6 100644 --- a/rai/lib/plat/windows/priority.cpp +++ b/nano/lib/plat/windows/priority.cpp @@ -1,8 +1,8 @@ -#include +#include #include -void rai::work_thread_reprioritize () +void nano::work_thread_reprioritize () { auto SUCCESS (SetThreadPriority (GetCurrentThread (), THREAD_MODE_BACKGROUND_BEGIN)); } diff --git a/rai/lib/plat/windows/thread_role.cpp b/nano/lib/plat/windows/thread_role.cpp similarity index 84% rename from rai/lib/plat/windows/thread_role.cpp rename to nano/lib/plat/windows/thread_role.cpp index fa0b775b..b77ba4a2 100644 --- a/rai/lib/plat/windows/thread_role.cpp +++ b/nano/lib/plat/windows/thread_role.cpp @@ -1,11 +1,11 @@ #include +#include #include -#include typedef HRESULT (*SetThreadDescription_t) (HANDLE, PCWSTR); -void rai::thread_role::set_name (std::string thread_name) +void nano::thread_role::set_name (std::string thread_name) { SetThreadDescription_t SetThreadDescription_local; diff --git a/rai/lib/utility.cpp b/nano/lib/utility.cpp similarity index 60% rename from rai/lib/utility.cpp rename to nano/lib/utility.cpp index a8242cfc..a2b3c392 100644 --- a/rai/lib/utility.cpp +++ b/nano/lib/utility.cpp @@ -1,61 +1,61 @@ #include -#include +#include -namespace rai +namespace nano { namespace thread_role { /* - * rai::thread_role namespace + * nano::thread_role namespace * * Manage thread role */ - static thread_local rai::thread_role::name current_thread_role = rai::thread_role::name::unknown; - rai::thread_role::name get (void) + static thread_local nano::thread_role::name current_thread_role = nano::thread_role::name::unknown; + nano::thread_role::name get (void) { return current_thread_role; } - void set (rai::thread_role::name role) + void set (nano::thread_role::name role) { std::string thread_role_name_string; switch (role) { - case rai::thread_role::name::unknown: + case nano::thread_role::name::unknown: thread_role_name_string = ""; break; - case rai::thread_role::name::io: + case nano::thread_role::name::io: thread_role_name_string = "I/O"; break; - case rai::thread_role::name::work: + case nano::thread_role::name::work: thread_role_name_string = "Work pool"; break; - case rai::thread_role::name::packet_processing: + case nano::thread_role::name::packet_processing: thread_role_name_string = "Pkt processing"; break; - case rai::thread_role::name::alarm: + case nano::thread_role::name::alarm: thread_role_name_string = "Alarm"; break; - case rai::thread_role::name::vote_processing: + case nano::thread_role::name::vote_processing: thread_role_name_string = "Vote processing"; break; - case rai::thread_role::name::block_processing: + case nano::thread_role::name::block_processing: thread_role_name_string = "Blck processing"; break; - case rai::thread_role::name::announce_loop: + case nano::thread_role::name::announce_loop: thread_role_name_string = "Announce loop"; break; - case rai::thread_role::name::wallet_actions: + case nano::thread_role::name::wallet_actions: thread_role_name_string = "Wallet actions"; break; - case rai::thread_role::name::bootstrap_initiator: + case nano::thread_role::name::bootstrap_initiator: thread_role_name_string = "Bootstrap init"; break; - case rai::thread_role::name::voting: + case nano::thread_role::name::voting: thread_role_name_string = "Voting"; break; - case rai::thread_role::name::signature_checking: + case nano::thread_role::name::signature_checking: thread_role_name_string = "Signature check"; break; } @@ -68,14 +68,14 @@ namespace thread_role */ assert (thread_role_name_string.size () < 16); - rai::thread_role::set_name (thread_role_name_string); + nano::thread_role::set_name (thread_role_name_string); - rai::thread_role::current_thread_role = role; + nano::thread_role::current_thread_role = role; } } } -void rai::thread_attributes::set (boost::thread::attributes & attrs) +void nano::thread_attributes::set (boost::thread::attributes & attrs) { auto attrs_l (&attrs); attrs_l->set_stack_size (8000000); //8MB diff --git a/rai/lib/utility.hpp b/nano/lib/utility.hpp similarity index 95% rename from rai/lib/utility.hpp rename to nano/lib/utility.hpp index 5cba8f89..2923d397 100644 --- a/rai/lib/utility.hpp +++ b/nano/lib/utility.hpp @@ -9,7 +9,7 @@ #include #include -namespace rai +namespace nano { // Lower priority of calling work generating thread void work_thread_reprioritize (); @@ -43,8 +43,8 @@ namespace thread_role voting, signature_checking, }; - rai::thread_role::name get (void); - void set (rai::thread_role::name); + nano::thread_role::name get (void); + void set (nano::thread_role::name); void set_name (std::string); } diff --git a/rai/lib/work.cpp b/nano/lib/work.cpp similarity index 71% rename from rai/lib/work.cpp rename to nano/lib/work.cpp index c3450da0..54aafe62 100644 --- a/rai/lib/work.cpp +++ b/nano/lib/work.cpp @@ -1,26 +1,26 @@ -#include +#include -#include -#include +#include +#include #include -bool rai::work_validate (rai::block_hash const & root_a, uint64_t work_a, uint64_t * difficulty_a) +bool nano::work_validate (nano::block_hash const & root_a, uint64_t work_a, uint64_t * difficulty_a) { - auto value (rai::work_value (root_a, work_a)); + auto value (nano::work_value (root_a, work_a)); if (difficulty_a != nullptr) { *difficulty_a = value; } - return value < rai::work_pool::publish_threshold; + return value < nano::work_pool::publish_threshold; } -bool rai::work_validate (rai::block const & block_a, uint64_t * difficulty_a) +bool nano::work_validate (nano::block const & block_a, uint64_t * difficulty_a) { return work_validate (block_a.root (), block_a.block_work (), difficulty_a); } -uint64_t rai::work_value (rai::block_hash const & root_a, uint64_t work_a) +uint64_t nano::work_value (nano::block_hash const & root_a, uint64_t work_a) { uint64_t result; blake2b_state hash; @@ -31,27 +31,27 @@ uint64_t rai::work_value (rai::block_hash const & root_a, uint64_t work_a) return result; } -rai::work_pool::work_pool (unsigned max_threads_a, std::function (rai::uint256_union const &)> opencl_a) : +nano::work_pool::work_pool (unsigned max_threads_a, std::function (nano::uint256_union const &)> opencl_a) : ticket (0), done (false), opencl (opencl_a) { static_assert (ATOMIC_INT_LOCK_FREE == 2, "Atomic int needed"); boost::thread::attributes attrs; - rai::thread_attributes::set (attrs); - auto count (rai::rai_network == rai::rai_networks::rai_test_network ? 1 : std::min (max_threads_a, std::max (1u, boost::thread::hardware_concurrency ()))); + nano::thread_attributes::set (attrs); + auto count (nano::nano_network == nano::nano_networks::nano_test_network ? 1 : std::min (max_threads_a, std::max (1u, boost::thread::hardware_concurrency ()))); for (auto i (0); i < count; ++i) { auto thread (boost::thread (attrs, [this, i]() { - rai::thread_role::set (rai::thread_role::name::work); - rai::work_thread_reprioritize (); + nano::thread_role::set (nano::thread_role::name::work); + nano::work_thread_reprioritize (); loop (i); })); threads.push_back (std::move (thread)); } } -rai::work_pool::~work_pool () +nano::work_pool::~work_pool () { stop (); for (auto & i : threads) @@ -60,11 +60,11 @@ rai::work_pool::~work_pool () } } -void rai::work_pool::loop (uint64_t thread) +void nano::work_pool::loop (uint64_t thread) { // Quick RNG for work attempts. xorshift1024star rng; - rai::random_pool.GenerateBlock (reinterpret_cast (rng.s.data ()), rng.s.size () * sizeof (decltype (rng.s)::value_type)); + nano::random_pool.GenerateBlock (reinterpret_cast (rng.s.data ()), rng.s.size () * sizeof (decltype (rng.s)::value_type)); uint64_t work; uint64_t output; blake2b_state hash; @@ -105,7 +105,7 @@ void rai::work_pool::loop (uint64_t thread) if (ticket == ticket_l) { // If the ticket matches what we started with, we're the ones that found the solution - assert (output >= rai::work_pool::publish_threshold); + assert (output >= nano::work_pool::publish_threshold); assert (work_value (current_l.item, work) == output); // Signal other threads to stop their work next time they check ticket ++ticket; @@ -127,7 +127,7 @@ void rai::work_pool::loop (uint64_t thread) } } -void rai::work_pool::cancel (rai::uint256_union const & root_a) +void nano::work_pool::cancel (nano::uint256_union const & root_a) { std::lock_guard lock (mutex); if (!pending.empty ()) @@ -152,7 +152,7 @@ void rai::work_pool::cancel (rai::uint256_union const & root_a) }); } -void rai::work_pool::stop () +void nano::work_pool::stop () { { std::lock_guard lock (mutex); @@ -161,7 +161,7 @@ void rai::work_pool::stop () producer_condition.notify_all (); } -void rai::work_pool::generate (rai::uint256_union const & root_a, std::function const &)> callback_a, uint64_t difficulty_a) +void nano::work_pool::generate (nano::uint256_union const & root_a, std::function const &)> callback_a, uint64_t difficulty_a) { assert (!root_a.is_zero ()); boost::optional result; @@ -183,7 +183,7 @@ void rai::work_pool::generate (rai::uint256_union const & root_a, std::function< } } -uint64_t rai::work_pool::generate (rai::uint256_union const & hash_a, uint64_t difficulty_a) +uint64_t nano::work_pool::generate (nano::uint256_union const & hash_a, uint64_t difficulty_a) { std::promise> work; generate (hash_a, [&work](boost::optional work_a) { diff --git a/nano/lib/work.hpp b/nano/lib/work.hpp new file mode 100644 index 00000000..f6155ebc --- /dev/null +++ b/nano/lib/work.hpp @@ -0,0 +1,51 @@ +#pragma once + +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace nano +{ +class block; +bool work_validate (nano::block_hash const &, uint64_t, uint64_t * = nullptr); +bool work_validate (nano::block const &, uint64_t * = nullptr); +uint64_t work_value (nano::block_hash const &, uint64_t); +class opencl_work; +class work_item +{ +public: + nano::uint256_union item; + std::function const &)> callback; + uint64_t difficulty; +}; +class work_pool +{ +public: + work_pool (unsigned, std::function (nano::uint256_union const &)> = nullptr); + ~work_pool (); + void loop (uint64_t); + void stop (); + void cancel (nano::uint256_union const &); + void generate (nano::uint256_union const &, std::function const &)>, uint64_t = nano::work_pool::publish_threshold); + uint64_t generate (nano::uint256_union const &, uint64_t = nano::work_pool::publish_threshold); + std::atomic ticket; + bool done; + std::vector threads; + std::list pending; + std::mutex mutex; + std::condition_variable producer_condition; + std::function (nano::uint256_union const &)> opencl; + nano::observer_set work_observers; + // Local work threshold for rate-limiting publishing blocks. ~5 seconds of work. + static uint64_t const publish_test_threshold = 0xff00000000000000; + static uint64_t const publish_full_threshold = 0xffffffc000000000; + static uint64_t const publish_threshold = nano::nano_network == nano::nano_networks::nano_test_network ? publish_test_threshold : publish_full_threshold; +}; +} diff --git a/nano/nano_node/CMakeLists.txt b/nano/nano_node/CMakeLists.txt new file mode 100644 index 00000000..fa714a67 --- /dev/null +++ b/nano/nano_node/CMakeLists.txt @@ -0,0 +1,30 @@ +add_executable (nano_node + daemon.cpp + daemon.hpp + entry.cpp) + +target_link_libraries (nano_node + node + secure + argon2 + Boost::boost + ${PLATFORM_LIBS} +) + +target_compile_definitions(nano_node + PRIVATE + -DNANO_VERSION_MAJOR=${CPACK_PACKAGE_VERSION_MAJOR} + -DNANO_VERSION_MINOR=${CPACK_PACKAGE_VERSION_MINOR}) + +set_target_properties (nano_node + PROPERTIES + COMPILE_FLAGS + "-DQT_NO_KEYWORDS -DBOOST_ASIO_HAS_STD_ARRAY=1") + +if ((NANO_GUI OR RAIBLOCKS_GUI) AND NOT APPLE) + install(TARGETS nano_node + RUNTIME DESTINATION bin + LIBRARY DESTINATION lib + ARCHIVE DESTINATION lib + ) +endif() diff --git a/rai/rai_node/daemon.cpp b/nano/nano_node/daemon.cpp similarity index 64% rename from rai/rai_node/daemon.cpp rename to nano/nano_node/daemon.cpp index 5054a088..8fadd46a 100644 --- a/rai/rai_node/daemon.cpp +++ b/nano/nano_node/daemon.cpp @@ -1,18 +1,18 @@ -#include -#include +#include +#include #include #include #include -#include +#include -rai_daemon::daemon_config::daemon_config () : +nano_daemon::daemon_config::daemon_config () : rpc_enable (false), opencl_enable (false) { } -void rai_daemon::daemon_config::serialize_json (boost::property_tree::ptree & tree_a) +void nano_daemon::daemon_config::serialize_json (boost::property_tree::ptree & tree_a) { tree_a.put ("version", std::to_string (json_version)); tree_a.put ("rpc_enable", rpc_enable); @@ -28,7 +28,7 @@ void rai_daemon::daemon_config::serialize_json (boost::property_tree::ptree & tr tree_a.add_child ("opencl", opencl_l); } -bool rai_daemon::daemon_config::deserialize_json (bool & upgraded_a, boost::property_tree::ptree & tree_a) +bool nano_daemon::daemon_config::deserialize_json (bool & upgraded_a, boost::property_tree::ptree & tree_a) { auto error (false); try @@ -64,7 +64,7 @@ bool rai_daemon::daemon_config::deserialize_json (bool & upgraded_a, boost::prop return error; } -bool rai_daemon::daemon_config::upgrade_json (unsigned version_a, boost::property_tree::ptree & tree_a) +bool nano_daemon::daemon_config::upgrade_json (unsigned version_a, boost::property_tree::ptree & tree_a) { tree_a.put ("version", std::to_string (json_version)); auto result (false); @@ -94,42 +94,42 @@ bool rai_daemon::daemon_config::upgrade_json (unsigned version_a, boost::propert return result; } -void rai_daemon::daemon::run (boost::filesystem::path const & data_path, rai::node_flags const & flags) +void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano::node_flags const & flags) { boost::system::error_code error_chmod; boost::filesystem::create_directories (data_path); - rai_daemon::daemon_config config; - rai::set_secure_perm_directory (data_path, error_chmod); + nano_daemon::daemon_config config; + nano::set_secure_perm_directory (data_path, error_chmod); auto config_path ((data_path / "config.json")); std::fstream config_file; - std::unique_ptr runner; - auto error (rai::fetch_object (config, config_path, config_file)); - rai::set_secure_perm_file (config_path, error_chmod); + std::unique_ptr runner; + auto error (nano::fetch_object (config, config_path, config_file)); + nano::set_secure_perm_file (config_path, error_chmod); if (!error) { config.node.logging.init (data_path); config_file.close (); boost::asio::io_context io_ctx; - auto opencl (rai::opencl_work::create (config.opencl_enable, config.opencl, config.node.logging)); - rai::work_pool opencl_work (config.node.work_threads, opencl ? [&opencl](rai::uint256_union const & root_a) { + auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, config.node.logging)); + nano::work_pool opencl_work (config.node.work_threads, opencl ? [&opencl](nano::uint256_union const & root_a) { return opencl->generate_work (root_a); } - : std::function (rai::uint256_union const &)> (nullptr)); - rai::alarm alarm (io_ctx); - rai::node_init init; + : std::function (nano::uint256_union const &)> (nullptr)); + nano::alarm alarm (io_ctx); + nano::node_init init; try { - auto node (std::make_shared (init, io_ctx, data_path, alarm, config.node, opencl_work)); + auto node (std::make_shared (init, io_ctx, data_path, alarm, config.node, opencl_work)); if (!init.error ()) { node->flags = flags; node->start (); - std::unique_ptr rpc = get_rpc (io_ctx, *node, config.rpc); + std::unique_ptr rpc = get_rpc (io_ctx, *node, config.rpc); if (rpc && config.rpc_enable) { rpc->start (); } - runner = std::make_unique (io_ctx, node->config.io_threads); + runner = std::make_unique (io_ctx, node->config.io_threads); runner->join (); } else diff --git a/rai/rai_node/daemon.hpp b/nano/nano_node/daemon.hpp similarity index 59% rename from rai/rai_node/daemon.hpp rename to nano/nano_node/daemon.hpp index ca30ba99..f9969b76 100644 --- a/rai/rai_node/daemon.hpp +++ b/nano/nano_node/daemon.hpp @@ -1,12 +1,12 @@ -#include -#include +#include +#include -namespace rai_daemon +namespace nano_daemon { class daemon { public: - void run (boost::filesystem::path const &, rai::node_flags const & flags); + void run (boost::filesystem::path const &, nano::node_flags const & flags); }; class daemon_config { @@ -16,10 +16,10 @@ public: void serialize_json (boost::property_tree::ptree &); bool upgrade_json (unsigned, boost::property_tree::ptree &); bool rpc_enable; - rai::rpc_config rpc; - rai::node_config node; + nano::rpc_config rpc; + nano::node_config node; bool opencl_enable; - rai::opencl_config opencl; + nano::opencl_config opencl; static constexpr int json_version = 2; }; } diff --git a/rai/rai_node/entry.cpp b/nano/nano_node/entry.cpp similarity index 73% rename from rai/rai_node/entry.cpp rename to nano/nano_node/entry.cpp index 021307fc..87770ba3 100644 --- a/rai/rai_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -1,8 +1,8 @@ -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include #include @@ -11,10 +11,10 @@ int main (int argc, char * const * argv) { - rai::set_umask (); + nano::set_umask (); boost::program_options::options_description description ("Command line options"); - rai::add_node_options (description); + nano::add_node_options (description); // clang-format off description.add_options () @@ -38,8 +38,8 @@ int main (int argc, char * const * argv) ("debug_verify_profile_batch", "Profile batch signature verification") ("debug_profile_bootstrap", "Profile bootstrap style blocks processing (at least 10GB of free storage space required)") ("debug_profile_sign", "Profile signature generation") - ("debug_profile_process", "Profile active blocks processing (only for rai_test_network)") - ("debug_profile_votes", "Profile votes processing (only for rai_test_network)") + ("debug_profile_process", "Profile active blocks processing (only for nano_test_network)") + ("debug_profile_votes", "Profile votes processing (only for nano_test_network)") ("debug_validate_blocks", "Check all blocks for correct hash, signature, work value") ("platform", boost::program_options::value (), "Defines the for OpenCL commands") ("device", boost::program_options::value (), "Defines for OpenCL command") @@ -58,15 +58,15 @@ int main (int argc, char * const * argv) } boost::program_options::notify (vm); int result (0); - boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : rai::working_path (); - auto ec = rai::handle_node_options (vm); + boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : nano::working_path (); + auto ec = nano::handle_node_options (vm); - if (ec == rai::error_cli::unknown_command) + if (ec == nano::error_cli::unknown_command) { if (vm.count ("daemon") > 0) { - rai_daemon::daemon daemon; - rai::node_flags flags; + nano_daemon::daemon daemon; + nano::node_flags flags; flags.disable_backup = (vm.count ("disable_backup") > 0); flags.disable_lazy_bootstrap = (vm.count ("disable_lazy_bootstrap") > 0); flags.disable_legacy_bootstrap = (vm.count ("disable_legacy_bootstrap") > 0); @@ -75,7 +75,7 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_block_count")) { - rai::inactive_node node (data_path); + nano::inactive_node node (data_path); auto transaction (node.node->store.tx_begin ()); std::cout << boost::str (boost::format ("Block count: %1%\n") % node.node->store.block_count (transaction).sum ()); } @@ -83,38 +83,38 @@ int main (int argc, char * const * argv) { if (vm.count ("key") == 1) { - rai::uint256_union key; + nano::uint256_union key; if (!key.decode_hex (vm["key"].as ())) { - rai::keypair genesis (key.to_string ()); - rai::work_pool work (std::numeric_limits::max (), nullptr); + nano::keypair genesis (key.to_string ()); + nano::work_pool work (std::numeric_limits::max (), nullptr); std::cout << "Genesis: " << genesis.prv.data.to_string () << std::endl << "Public: " << genesis.pub.to_string () << std::endl << "Account: " << genesis.pub.to_account () << std::endl; - rai::keypair landing; + nano::keypair landing; std::cout << "Landing: " << landing.prv.data.to_string () << std::endl << "Public: " << landing.pub.to_string () << std::endl << "Account: " << landing.pub.to_account () << std::endl; for (auto i (0); i != 32; ++i) { - rai::keypair rep; + nano::keypair rep; std::cout << "Rep" << i << ": " << rep.prv.data.to_string () << std::endl << "Public: " << rep.pub.to_string () << std::endl << "Account: " << rep.pub.to_account () << std::endl; } - rai::uint128_t balance (std::numeric_limits::max ()); - rai::open_block genesis_block (genesis.pub, genesis.pub, genesis.pub, genesis.prv, genesis.pub, work.generate (genesis.pub)); + nano::uint128_t balance (std::numeric_limits::max ()); + nano::open_block genesis_block (genesis.pub, genesis.pub, genesis.pub, genesis.prv, genesis.pub, work.generate (genesis.pub)); std::cout << genesis_block.to_json (); - rai::block_hash previous (genesis_block.hash ()); + nano::block_hash previous (genesis_block.hash ()); for (auto i (0); i != 8; ++i) { - rai::uint128_t yearly_distribution (rai::uint128_t (1) << (127 - (i == 7 ? 6 : i))); + nano::uint128_t yearly_distribution (nano::uint128_t (1) << (127 - (i == 7 ? 6 : i))); auto weekly_distribution (yearly_distribution / 52); for (auto j (0); j != 52; ++j) { assert (balance > weekly_distribution); balance = balance < (weekly_distribution * 2) ? 0 : balance - weekly_distribution; - rai::send_block send (previous, landing.pub, balance, genesis.prv, genesis.pub, work.generate (previous)); + nano::send_block send (previous, landing.pub, balance, genesis.prv, genesis.pub, work.generate (previous)); previous = send.hash (); std::cout << send.to_json (); std::cout.flush (); @@ -135,21 +135,21 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_dump_representatives")) { - rai::inactive_node node (data_path); + nano::inactive_node node (data_path); auto transaction (node.node->store.tx_begin ()); - rai::uint128_t total; + nano::uint128_t total; for (auto i (node.node->store.representation_begin (transaction)), n (node.node->store.representation_end ()); i != n; ++i) { - rai::account account (i->first); + nano::account account (i->first); auto amount (node.node->store.representation_get (transaction, account)); total += amount; std::cout << boost::str (boost::format ("%1% %2% %3%\n") % account.to_account () % amount.convert_to () % total.convert_to ()); } - std::map calculated; + std::map calculated; for (auto i (node.node->store.latest_begin (transaction)), n (node.node->store.latest_end ()); i != n; ++i) { - rai::account_info info (i->second); - rai::block_hash rep_block (node.node->ledger.representative_calculated (transaction, info.head)); + nano::account_info info (i->second); + nano::block_hash rep_block (node.node->ledger.representative_calculated (transaction, info.head)); auto block (node.node->store.block_get (transaction, rep_block)); calculated[block->representative ()] += info.balance.number (); } @@ -162,25 +162,25 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_account_count")) { - rai::inactive_node node (data_path); + nano::inactive_node node (data_path); auto transaction (node.node->store.tx_begin ()); std::cout << boost::str (boost::format ("Frontier count: %1%\n") % node.node->store.account_count (transaction)); } else if (vm.count ("debug_mass_activity")) { - rai::system system (24000, 1); + nano::system system (24000, 1); size_t count (1000000); system.generate_mass_activity (count, *system.nodes[0]); } else if (vm.count ("debug_profile_kdf")) { - rai::uint256_union result; - rai::uint256_union salt (0); + nano::uint256_union result; + nano::uint256_union salt (0); std::string password (""); for (; true;) { auto begin1 (std::chrono::high_resolution_clock::now ()); - auto success (argon2_hash (1, rai::wallet_store::kdf_work, 1, password.data (), password.size (), salt.bytes.data (), salt.bytes.size (), result.bytes.data (), result.bytes.size (), NULL, 0, Argon2_d, 0x10)); + auto success (argon2_hash (1, nano::wallet_store::kdf_work, 1, password.data (), password.size (), salt.bytes.data (), salt.bytes.size (), result.bytes.data (), result.bytes.size (), NULL, 0, Argon2_d, 0x10)); (void)success; auto end1 (std::chrono::high_resolution_clock::now ()); std::cerr << boost::str (boost::format ("Derivation time: %1%us\n") % std::chrono::duration_cast (end1 - begin1).count ()); @@ -188,8 +188,8 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_profile_generate")) { - rai::work_pool work (std::numeric_limits::max (), nullptr); - rai::change_block block (0, 0, rai::keypair ().prv, 0, 0); + nano::work_pool work (std::numeric_limits::max (), nullptr); + nano::change_block block (0, 0, nano::keypair ().prv, 0, 0); std::cerr << "Starting generation profiling\n"; for (uint64_t i (0); true; ++i) { @@ -203,7 +203,7 @@ int main (int argc, char * const * argv) else if (vm.count ("debug_opencl")) { bool error (false); - rai::opencl_environment environment (error); + nano::opencl_environment environment (error); if (!error) { unsigned short platform (0); @@ -253,13 +253,13 @@ int main (int argc, char * const * argv) error |= device >= environment.platforms[platform].devices.size (); if (!error) { - rai::logging logging; - auto opencl (rai::opencl_work::create (true, { platform, device, threads }, logging)); - rai::work_pool work_pool (std::numeric_limits::max (), opencl ? [&opencl](rai::uint256_union const & root_a) { + nano::logging logging; + auto opencl (nano::opencl_work::create (true, { platform, device, threads }, logging)); + nano::work_pool work_pool (std::numeric_limits::max (), opencl ? [&opencl](nano::uint256_union const & root_a) { return opencl->generate_work (root_a); } - : std::function (rai::uint256_union const &)> (nullptr)); - rai::change_block block (0, 0, rai::keypair ().prv, 0, 0); + : std::function (nano::uint256_union const &)> (nullptr)); + nano::change_block block (0, 0, nano::keypair ().prv, 0, 0); std::cerr << boost::str (boost::format ("Starting OpenCL generation profiling. Platform: %1%. Device: %2%. Threads: %3%\n") % platform % device % threads); for (uint64_t i (0); true; ++i) { @@ -293,8 +293,8 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_profile_verify")) { - rai::work_pool work (std::numeric_limits::max (), nullptr); - rai::change_block block (0, 0, rai::keypair ().prv, 0, 0); + nano::work_pool work (std::numeric_limits::max (), nullptr); + nano::change_block block (0, 0, nano::keypair ().prv, 0, 0); std::cerr << "Starting verification profiling\n"; for (uint64_t i (0); true; ++i) { @@ -304,7 +304,7 @@ int main (int argc, char * const * argv) { block.hashables.previous.qwords[0] += 1; block.block_work_set (t); - rai::work_validate (block); + nano::work_validate (block); } auto end1 (std::chrono::high_resolution_clock::now ()); std::cerr << boost::str (boost::format ("%|1$ 12d|\n") % std::chrono::duration_cast (end1 - begin1).count ()); @@ -312,24 +312,24 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_verify_profile")) { - rai::keypair key; - rai::uint256_union message; - rai::uint512_union signature; - signature = rai::sign_message (key.prv, key.pub, message); + nano::keypair key; + nano::uint256_union message; + nano::uint512_union signature; + signature = nano::sign_message (key.prv, key.pub, message); auto begin (std::chrono::high_resolution_clock::now ()); for (auto i (0u); i < 1000; ++i) { - rai::validate_message (key.pub, message, signature); + nano::validate_message (key.pub, message, signature); } auto end (std::chrono::high_resolution_clock::now ()); std::cerr << "Signature verifications " << std::chrono::duration_cast (end - begin).count () << std::endl; } else if (vm.count ("debug_verify_profile_batch")) { - rai::keypair key; + nano::keypair key; size_t batch_count (1000); - rai::uint256_union message; - rai::uint512_union signature (rai::sign_message (key.prv, key.pub, message)); + nano::uint256_union message; + nano::uint512_union signature (nano::sign_message (key.prv, key.pub, message)); std::vector messages (batch_count, message.bytes.data ()); std::vector lengths (batch_count, sizeof (message)); std::vector pub_keys (batch_count, key.pub.bytes.data ()); @@ -337,7 +337,7 @@ int main (int argc, char * const * argv) std::vector verifications; verifications.resize (batch_count); auto begin (std::chrono::high_resolution_clock::now ()); - rai::validate_message_batch (messages.data (), lengths.data (), pub_keys.data (), signatures.data (), batch_count, verifications.data ()); + nano::validate_message_batch (messages.data (), lengths.data (), pub_keys.data (), signatures.data (), batch_count, verifications.data ()); auto end (std::chrono::high_resolution_clock::now ()); std::cerr << "Batch signature verifications " << std::chrono::duration_cast (end - begin).count () << std::endl; } @@ -346,12 +346,12 @@ int main (int argc, char * const * argv) std::cerr << "Starting blocks signing profiling\n"; for (uint64_t i (0); true; ++i) { - rai::keypair key; - rai::block_hash latest (0); + nano::keypair key; + nano::block_hash latest (0); auto begin1 (std::chrono::high_resolution_clock::now ()); for (uint64_t balance (0); balance < 1000; ++balance) { - rai::send_block send (latest, key.pub, balance, key.prv, key.pub, 0); + nano::send_block send (latest, key.pub, balance, key.prv, key.pub, 0); latest = send.hash (); } auto end1 (std::chrono::high_resolution_clock::now ()); @@ -360,34 +360,34 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_profile_process")) { - if (rai::rai_network == rai::rai_networks::rai_test_network) + if (nano::nano_network == nano::nano_networks::nano_test_network) { size_t num_accounts (100000); size_t num_interations (5); // 100,000 * 5 * 2 = 1,000,000 blocks size_t max_blocks (2 * num_accounts * num_interations + num_accounts * 2); // 1,000,000 + 2* 100,000 = 1,200,000 blocks std::cerr << boost::str (boost::format ("Starting pregenerating %1% blocks\n") % max_blocks); - rai::system system (24000, 1); - rai::node_init init; - rai::work_pool work (std::numeric_limits::max (), nullptr); - rai::logging logging; - auto path (rai::unique_path ()); + nano::system system (24000, 1); + nano::node_init init; + nano::work_pool work (std::numeric_limits::max (), nullptr); + nano::logging logging; + auto path (nano::unique_path ()); logging.init (path); - auto node (std::make_shared (init, system.io_ctx, 24001, path, system.alarm, logging, work)); - rai::block_hash genesis_latest (node->latest (rai::test_genesis_key.pub)); - rai::uint128_t genesis_balance (std::numeric_limits::max ()); + auto node (std::make_shared (init, system.io_ctx, 24001, path, system.alarm, logging, work)); + nano::block_hash genesis_latest (node->latest (nano::test_genesis_key.pub)); + nano::uint128_t genesis_balance (std::numeric_limits::max ()); // Generating keys - std::vector keys (num_accounts); - std::vector frontiers (num_accounts); - std::vector balances (num_accounts, 1000000000); + std::vector keys (num_accounts); + std::vector frontiers (num_accounts); + std::vector balances (num_accounts, 1000000000); // Generating blocks - std::deque> blocks; + std::deque> blocks; for (auto i (0); i != num_accounts; ++i) { genesis_balance = genesis_balance - 1000000000; - auto send (std::make_shared (rai::test_genesis_key.pub, genesis_latest, rai::test_genesis_key.pub, genesis_balance, keys[i].pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, work.generate (genesis_latest))); + auto send (std::make_shared (nano::test_genesis_key.pub, genesis_latest, nano::test_genesis_key.pub, genesis_balance, keys[i].pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, work.generate (genesis_latest))); genesis_latest = send->hash (); blocks.push_back (std::move (send)); - auto open (std::make_shared (keys[i].pub, 0, keys[i].pub, balances[i], genesis_latest, keys[i].prv, keys[i].pub, work.generate (keys[i].pub))); + auto open (std::make_shared (keys[i].pub, 0, keys[i].pub, balances[i], genesis_latest, keys[i].prv, keys[i].pub, work.generate (keys[i].pub))); frontiers[i] = open->hash (); blocks.push_back (std::move (open)); } @@ -398,12 +398,12 @@ int main (int argc, char * const * argv) size_t other (num_accounts - j - 1); // Sending to other account --balances[j]; - auto send (std::make_shared (keys[j].pub, frontiers[j], keys[j].pub, balances[j], keys[other].pub, keys[j].prv, keys[j].pub, work.generate (frontiers[j]))); + auto send (std::make_shared (keys[j].pub, frontiers[j], keys[j].pub, balances[j], keys[other].pub, keys[j].prv, keys[j].pub, work.generate (frontiers[j]))); frontiers[j] = send->hash (); blocks.push_back (std::move (send)); // Receiving ++balances[other]; - auto receive (std::make_shared (keys[other].pub, frontiers[other], keys[other].pub, balances[other], frontiers[j], keys[other].prv, keys[other].pub, work.generate (frontiers[other]))); + auto receive (std::make_shared (keys[other].pub, frontiers[other], keys[other].pub, balances[other], frontiers[j], keys[other].prv, keys[other].pub, work.generate (frontiers[other]))); frontiers[other] = receive->hash (); blocks.push_back (std::move (receive)); } @@ -431,57 +431,57 @@ int main (int argc, char * const * argv) } else { - std::cerr << "For this test ACTIVE_NETWORK should be rai_test_network" << std::endl; + std::cerr << "For this test ACTIVE_NETWORK should be nano_test_network" << std::endl; } } else if (vm.count ("debug_profile_votes")) { - if (rai::rai_network == rai::rai_networks::rai_test_network) + if (nano::nano_network == nano::nano_networks::nano_test_network) { size_t num_elections (40000); size_t num_representatives (25); size_t max_votes (num_elections * num_representatives); // 40,000 * 25 = 1,000,000 votes std::cerr << boost::str (boost::format ("Starting pregenerating %1% votes\n") % max_votes); - rai::system system (24000, 1); - rai::node_init init; - rai::work_pool work (std::numeric_limits::max (), nullptr); - rai::logging logging; - auto path (rai::unique_path ()); + nano::system system (24000, 1); + nano::node_init init; + nano::work_pool work (std::numeric_limits::max (), nullptr); + nano::logging logging; + auto path (nano::unique_path ()); logging.init (path); - auto node (std::make_shared (init, system.io_ctx, 24001, path, system.alarm, logging, work)); - rai::block_hash genesis_latest (node->latest (rai::test_genesis_key.pub)); - rai::uint128_t genesis_balance (std::numeric_limits::max ()); + auto node (std::make_shared (init, system.io_ctx, 24001, path, system.alarm, logging, work)); + nano::block_hash genesis_latest (node->latest (nano::test_genesis_key.pub)); + nano::uint128_t genesis_balance (std::numeric_limits::max ()); // Generating keys - std::vector keys (num_representatives); - rai::uint128_t balance ((node->config.online_weight_minimum.number () / num_representatives) + 1); + std::vector keys (num_representatives); + nano::uint128_t balance ((node->config.online_weight_minimum.number () / num_representatives) + 1); for (auto i (0); i != num_representatives; ++i) { auto transaction (node->store.tx_begin_write ()); genesis_balance = genesis_balance - balance; - rai::state_block send (rai::test_genesis_key.pub, genesis_latest, rai::test_genesis_key.pub, genesis_balance, keys[i].pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, work.generate (genesis_latest)); + nano::state_block send (nano::test_genesis_key.pub, genesis_latest, nano::test_genesis_key.pub, genesis_balance, keys[i].pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, work.generate (genesis_latest)); genesis_latest = send.hash (); node->ledger.process (transaction, send); - rai::state_block open (keys[i].pub, 0, keys[i].pub, balance, genesis_latest, keys[i].prv, keys[i].pub, work.generate (keys[i].pub)); + nano::state_block open (keys[i].pub, 0, keys[i].pub, balance, genesis_latest, keys[i].prv, keys[i].pub, work.generate (keys[i].pub)); node->ledger.process (transaction, open); } // Generating blocks - std::deque> blocks; + std::deque> blocks; for (auto i (0); i != num_elections; ++i) { genesis_balance = genesis_balance - 1; - rai::keypair destination; - auto send (std::make_shared (rai::test_genesis_key.pub, genesis_latest, rai::test_genesis_key.pub, genesis_balance, destination.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, work.generate (genesis_latest))); + nano::keypair destination; + auto send (std::make_shared (nano::test_genesis_key.pub, genesis_latest, nano::test_genesis_key.pub, genesis_balance, destination.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, work.generate (genesis_latest))); genesis_latest = send->hash (); blocks.push_back (send); } // Generating votes - std::deque> votes; + std::deque> votes; for (auto j (0); j != num_representatives; ++j) { uint64_t sequence (1); for (auto & i : blocks) { - auto vote (std::make_shared (keys[j].pub, keys[j].prv, sequence, std::vector (1, i->hash ()))); + auto vote (std::make_shared (keys[j].pub, keys[j].prv, sequence, std::vector (1, i->hash ()))); votes.push_back (vote); sequence++; } @@ -514,12 +514,12 @@ int main (int argc, char * const * argv) } else { - std::cerr << "For this test ACTIVE_NETWORK should be rai_test_network" << std::endl; + std::cerr << "For this test ACTIVE_NETWORK should be nano_test_network" << std::endl; } } else if (vm.count ("debug_validate_blocks")) { - rai::inactive_node node (data_path); + nano::inactive_node node (data_path); auto transaction (node.node->store.tx_begin ()); std::cerr << boost::str (boost::format ("Performing blocks hash, signature, work validation...\n")); size_t count (0); @@ -530,16 +530,16 @@ int main (int argc, char * const * argv) { std::cout << boost::str (boost::format ("%1% accounts validated\n") % count); } - rai::account_info info (i->second); - rai::account account (i->first); + nano::account_info info (i->second); + nano::account account (i->first); auto hash (info.open_block); - rai::block_hash calculated_hash (0); + nano::block_hash calculated_hash (0); while (!hash.is_zero ()) { // Retrieving block data auto block (node.node->store.block_get (transaction, hash)); // Check for state & open blocks if account field is correct - if ((block->type () == rai::block_type::open && block->root () != account) || (block->type () == rai::block_type::state && static_cast (*block.get ()).hashables.account != account)) + if ((block->type () == nano::block_type::open && block->root () != account) || (block->type () == nano::block_type::state && static_cast (*block.get ()).hashables.account != account)) { std::cerr << boost::str (boost::format ("Incorrect account field for block %1%\n") % hash.to_string ()); } @@ -559,10 +559,10 @@ int main (int argc, char * const * argv) { bool invalid (true); // Epoch blocks - if (!node.node->ledger.epoch_link.is_zero () && block->type () == rai::block_type::state) + if (!node.node->ledger.epoch_link.is_zero () && block->type () == nano::block_type::state) { - auto & state_block (static_cast (*block.get ())); - rai::amount prev_balance (0); + auto & state_block (static_cast (*block.get ())); + nano::amount prev_balance (0); if (!state_block.hashables.previous.is_zero ()) { prev_balance = node.node->ledger.balance (transaction, state_block.hashables.previous); @@ -578,9 +578,9 @@ int main (int argc, char * const * argv) } } // Check if block work value is correct - if (rai::work_validate (*block.get ())) + if (nano::work_validate (*block.get ())) { - std::cerr << boost::str (boost::format ("Invalid work for block %1% value: %2%\n") % hash.to_string () % rai::to_string_hex (block->block_work ())); + std::cerr << boost::str (boost::format ("Invalid work for block %1% value: %2%\n") % hash.to_string () % nano::to_string_hex (block->block_work ())); } // Retrieving successor block hash hash = node.node->store.block_successor (transaction, hash); @@ -595,8 +595,8 @@ int main (int argc, char * const * argv) { std::cout << boost::str (boost::format ("%1% pending blocks validated\n") % count); } - rai::pending_key key (i->first); - rai::pending_info info (i->second); + nano::pending_key key (i->first); + nano::pending_info info (i->second); // Check block existance auto block (node.node->store.block_get (transaction, key.hash)); if (block == nullptr) @@ -606,15 +606,15 @@ int main (int argc, char * const * argv) else { // Check if pending destination is correct - rai::account destination (0); - if (auto state = dynamic_cast (block.get ())) + nano::account destination (0); + if (auto state = dynamic_cast (block.get ())) { if (node.node->ledger.is_send (transaction, *state)) { destination = state->hashables.link; } } - else if (auto send = dynamic_cast (block.get ())) + else if (auto send = dynamic_cast (block.get ())) { destination = send->hashables.destination; } @@ -644,19 +644,19 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_profile_bootstrap")) { - rai::inactive_node node2 (rai::unique_path (), 24001); - rai::genesis genesis; + nano::inactive_node node2 (nano::unique_path (), 24001); + nano::genesis genesis; auto begin (std::chrono::high_resolution_clock::now ()); uint64_t block_count (0); size_t count (0); { - rai::inactive_node node (data_path, 24000); + nano::inactive_node node (data_path, 24000); auto transaction (node.node->store.tx_begin ()); block_count = node.node->store.block_count (transaction).sum (); std::cout << boost::str (boost::format ("Performing bootstrap emulation, %1% blocks in ledger...") % block_count) << std::endl; for (auto i (node.node->store.latest_begin (transaction)), n (node.node->store.latest_end ()); i != n; ++i) { - rai::account_info info (i->second); + nano::account_info info (i->second); auto hash (info.head); while (!hash.is_zero ()) { @@ -692,12 +692,12 @@ int main (int argc, char * const * argv) auto end (std::chrono::high_resolution_clock::now ()); auto time (std::chrono::duration_cast (end - begin).count ()); auto seconds (time / 1000000); - rai::remove_temporary_directories (); + nano::remove_temporary_directories (); std::cout << boost::str (boost::format ("%|1$ 12d| seconds \n%2% blocks per second") % seconds % (block_count / seconds)) << std::endl; } else if (vm.count ("version")) { - std::cout << "Version " << RAIBLOCKS_VERSION_MAJOR << "." << RAIBLOCKS_VERSION_MINOR << std::endl; + std::cout << "Version " << NANO_VERSION_MAJOR << "." << NANO_VERSION_MINOR << std::endl; } else { diff --git a/rai/rai_wallet/entry.cpp b/nano/nano_wallet/entry.cpp similarity index 80% rename from rai/rai_wallet/entry.cpp rename to nano/nano_wallet/entry.cpp index 20de1830..861cb2be 100644 --- a/rai/rai_wallet/entry.cpp +++ b/nano/nano_wallet/entry.cpp @@ -1,9 +1,9 @@ -#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include +#include #include #include @@ -18,7 +18,7 @@ public: rpc_enable (false), opencl_enable (false) { - rai::random_pool.GenerateBlock (wallet.bytes.data (), wallet.bytes.size ()); + nano::random_pool.GenerateBlock (wallet.bytes.data (), wallet.bytes.size ()); assert (!wallet.is_zero ()); } bool upgrade_json (unsigned version_a, boost::property_tree::ptree & tree_a) @@ -29,7 +29,7 @@ public: { case 1: { - rai::account account; + nano::account account; account.decode_account (tree_a.get ("account")); tree_a.erase ("account"); tree_a.put ("account", account.to_account ()); @@ -97,7 +97,7 @@ public: error |= opencl.deserialize_json (opencl_l); if (wallet.is_zero ()) { - rai::random_pool.GenerateBlock (wallet.bytes.data (), wallet.bytes.size ()); + nano::random_pool.GenerateBlock (wallet.bytes.data (), wallet.bytes.size ()); upgraded_a = true; } } @@ -150,13 +150,13 @@ public: } return result; } - rai::uint256_union wallet; - rai::account account; - rai::node_config node; + nano::uint256_union wallet; + nano::account account; + nano::node_config node; bool rpc_enable; - rai::rpc_config rpc; + nano::rpc_config rpc; bool opencl_enable; - rai::opencl_config opencl; + nano::opencl_config opencl; static constexpr int json_version = 4; }; @@ -174,7 +174,7 @@ bool update_config (qt_wallet_config & config_a, boost::filesystem::path const & auto account (config_a.account); auto wallet (config_a.wallet); auto error (false); - if (!rai::fetch_object (config_a, config_path_a, config_file_a)) + if (!nano::fetch_object (config_a, config_path_a, config_file_a)) { if (account != config_a.account || wallet != config_a.wallet) { @@ -189,12 +189,12 @@ bool update_config (qt_wallet_config & config_a, boost::filesystem::path const & } } -int run_wallet (QApplication & application, int argc, char * const * argv, boost::filesystem::path const & data_path, rai::node_flags const & flags) +int run_wallet (QApplication & application, int argc, char * const * argv, boost::filesystem::path const & data_path, nano::node_flags const & flags) { - rai_qt::eventloop_processor processor; + nano_qt::eventloop_processor processor; boost::system::error_code error_chmod; boost::filesystem::create_directories (data_path); - rai::set_secure_perm_directory (data_path, error_chmod); + nano::set_secure_perm_directory (data_path, error_chmod); QPixmap pixmap (":/logo.png"); QSplashScreen * splash = new QSplashScreen (pixmap); splash->show (); @@ -205,24 +205,24 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost auto config_path ((data_path / "config.json")); int result (0); std::fstream config_file; - auto error (rai::fetch_object (config, config_path, config_file)); + auto error (nano::fetch_object (config, config_path, config_file)); config_file.close (); - rai::set_secure_perm_file (config_path, error_chmod); + nano::set_secure_perm_file (config_path, error_chmod); if (!error) { boost::asio::io_context io_ctx; config.node.logging.init (data_path); - std::shared_ptr node; - std::shared_ptr gui; - rai::set_application_icon (application); - auto opencl (rai::opencl_work::create (config.opencl_enable, config.opencl, config.node.logging)); - rai::work_pool work (config.node.work_threads, opencl ? [&opencl](rai::uint256_union const & root_a) { + std::shared_ptr node; + std::shared_ptr gui; + nano::set_application_icon (application); + auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, config.node.logging)); + nano::work_pool work (config.node.work_threads, opencl ? [&opencl](nano::uint256_union const & root_a) { return opencl->generate_work (root_a); } - : std::function (rai::uint256_union const &)> (nullptr)); - rai::alarm alarm (io_ctx); - rai::node_init init; - node = std::make_shared (init, io_ctx, data_path, alarm, config.node, work); + : std::function (nano::uint256_union const &)> (nullptr)); + nano::alarm alarm (io_ctx); + nano::node_init init; + node = std::make_shared (init, io_ctx, data_path, alarm, config.node, work); if (!init.error ()) { auto wallet (node->wallets.open (config.wallet)); @@ -245,7 +245,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost auto existing (wallet->store.begin (transaction)); if (existing != wallet->store.end ()) { - rai::uint256_union account (existing->first); + nano::uint256_union account (existing->first); config.account = account; } else @@ -256,18 +256,18 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost assert (wallet->exists (config.account)); update_config (config, config_path, config_file); node->start (); - std::unique_ptr rpc = get_rpc (io_ctx, *node, config.rpc); + std::unique_ptr rpc = get_rpc (io_ctx, *node, config.rpc); if (rpc && config.rpc_enable) { rpc->start (); } - rai::thread_runner runner (io_ctx, node->config.io_threads); + nano::thread_runner runner (io_ctx, node->config.io_threads); QObject::connect (&application, &QApplication::aboutToQuit, [&]() { rpc->stop (); node->stop (); }); - application.postEvent (&processor, new rai_qt::eventloop_event ([&]() { - gui = std::make_shared (application, processor, *node, wallet, config.account); + application.postEvent (&processor, new nano_qt::eventloop_event ([&]() { + gui = std::make_shared (application, processor, *node, wallet, config.account); splash->close (); gui->start (); gui->client_window->show (); @@ -290,20 +290,20 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost int main (int argc, char * const * argv) { - rai::set_umask (); + nano::set_umask (); try { QApplication application (argc, const_cast (argv)); boost::program_options::options_description description ("Command line options"); description.add_options () ("help", "Print out options"); - rai::add_node_options (description); + nano::add_node_options (description); boost::program_options::variables_map vm; boost::program_options::store (boost::program_options::command_line_parser (argc, argv).options (description).allow_unregistered ().run (), vm); boost::program_options::notify (vm); int result (0); - auto ec = rai::handle_node_options (vm); - if (ec == rai::error_cli::unknown_command) + auto ec = nano::handle_node_options (vm); + if (ec == nano::error_cli::unknown_command) { if (vm.count ("help") != 0) { @@ -321,9 +321,9 @@ int main (int argc, char * const * argv) } else { - data_path = rai::working_path (); + data_path = nano::working_path (); } - rai::node_flags flags; + nano::node_flags flags; flags.disable_backup = (vm.count ("disable_backup") > 0); flags.disable_lazy_bootstrap = (vm.count ("disable_lazy_bootstrap") > 0); flags.disable_legacy_bootstrap = (vm.count ("disable_legacy_bootstrap") > 0); diff --git a/rai/rai_wallet/icon.hpp b/nano/nano_wallet/icon.hpp similarity index 84% rename from rai/rai_wallet/icon.hpp rename to nano/nano_wallet/icon.hpp index 5224d08b..3db25460 100644 --- a/rai/rai_wallet/icon.hpp +++ b/nano/nano_wallet/icon.hpp @@ -1,7 +1,7 @@ #pragma once class QApplication; -namespace rai +namespace nano { void set_application_icon (QApplication &); } diff --git a/nano/nano_wallet/plat/default/icon.cpp b/nano/nano_wallet/plat/default/icon.cpp new file mode 100644 index 00000000..2cb340ff --- /dev/null +++ b/nano/nano_wallet/plat/default/icon.cpp @@ -0,0 +1,5 @@ +#include + +void nano::set_application_icon (QApplication &) +{ +} diff --git a/rai/rai_wallet/plat/windows/icon.cpp b/nano/nano_wallet/plat/windows/icon.cpp similarity index 75% rename from rai/rai_wallet/plat/windows/icon.cpp rename to nano/nano_wallet/plat/windows/icon.cpp index 514c74ad..c69956c8 100644 --- a/rai/rai_wallet/plat/windows/icon.cpp +++ b/nano/nano_wallet/plat/windows/icon.cpp @@ -1,10 +1,10 @@ -#include +#include #include #include #include -void rai::set_application_icon (QApplication & application_a) +void nano::set_application_icon (QApplication & application_a) { HICON hIcon = static_cast (LoadImage (GetModuleHandle (nullptr), MAKEINTRESOURCE (1), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE | LR_LOADTRANSPARENT)); application_a.setWindowIcon (QIcon (QtWin::fromHICON (hIcon))); diff --git a/rai/node/CMakeLists.txt b/nano/node/CMakeLists.txt similarity index 88% rename from rai/node/CMakeLists.txt rename to nano/node/CMakeLists.txt index f6ea0ced..07397c09 100644 --- a/rai/node/CMakeLists.txt +++ b/nano/node/CMakeLists.txt @@ -1,4 +1,4 @@ -if (RAIBLOCKS_SECURE_RPC) +if (NANO_SECURE_RPC OR RAIBLOCKS_SECURE_RPC) set (secure_rpc_sources rpc_secure.cpp rpc_secure.hpp) endif () @@ -52,7 +52,7 @@ add_library (node target_link_libraries (node secure - rai_lib + nano_lib libminiupnpc-static argon2 lmdb @@ -69,5 +69,5 @@ target_link_libraries (node target_compile_definitions(node PRIVATE - -DRAIBLOCKS_VERSION_MAJOR=${CPACK_PACKAGE_VERSION_MAJOR} - -DRAIBLOCKS_VERSION_MINOR=${CPACK_PACKAGE_VERSION_MINOR}) + -DNANO_VERSION_MAJOR=${CPACK_PACKAGE_VERSION_MAJOR} + -DNANO_VERSION_MINOR=${CPACK_PACKAGE_VERSION_MINOR}) diff --git a/rai/node/bootstrap.cpp b/nano/node/bootstrap.cpp similarity index 71% rename from rai/node/bootstrap.cpp rename to nano/node/bootstrap.cpp index 699a4614..47768408 100644 --- a/rai/node/bootstrap.cpp +++ b/nano/node/bootstrap.cpp @@ -1,7 +1,7 @@ -#include +#include -#include -#include +#include +#include #include @@ -14,14 +14,14 @@ constexpr double bootstrap_minimum_termination_time_sec = 30.0; constexpr unsigned bootstrap_max_new_connections = 10; constexpr unsigned bulk_push_cost_limit = 200; -rai::socket::socket (std::shared_ptr node_a) : +nano::socket::socket (std::shared_ptr node_a) : socket_m (node_a->io_ctx), cutoff (std::numeric_limits::max ()), node (node_a) { } -void rai::socket::async_connect (rai::tcp_endpoint const & endpoint_a, std::function callback_a) +void nano::socket::async_connect (nano::tcp_endpoint const & endpoint_a, std::function callback_a) { checkup (); auto this_l (shared_from_this ()); @@ -32,40 +32,40 @@ void rai::socket::async_connect (rai::tcp_endpoint const & endpoint_a, std::func }); } -void rai::socket::async_read (std::shared_ptr> buffer_a, size_t size_a, std::function callback_a) +void nano::socket::async_read (std::shared_ptr> buffer_a, size_t size_a, std::function callback_a) { assert (size_a <= buffer_a->size ()); auto this_l (shared_from_this ()); start (); boost::asio::async_read (socket_m, boost::asio::buffer (buffer_a->data (), size_a), [this_l, callback_a](boost::system::error_code const & ec, size_t size_a) { - this_l->node->stats.add (rai::stat::type::traffic_bootstrap, rai::stat::dir::in, size_a); + this_l->node->stats.add (nano::stat::type::traffic_bootstrap, nano::stat::dir::in, size_a); this_l->stop (); callback_a (ec, size_a); }); } -void rai::socket::async_write (std::shared_ptr> buffer_a, std::function callback_a) +void nano::socket::async_write (std::shared_ptr> buffer_a, std::function callback_a) { auto this_l (shared_from_this ()); start (); boost::asio::async_write (socket_m, boost::asio::buffer (buffer_a->data (), buffer_a->size ()), [this_l, callback_a, buffer_a](boost::system::error_code const & ec, size_t size_a) { - this_l->node->stats.add (rai::stat::type::traffic_bootstrap, rai::stat::dir::out, size_a); + this_l->node->stats.add (nano::stat::type::traffic_bootstrap, nano::stat::dir::out, size_a); this_l->stop (); callback_a (ec, size_a); }); } -void rai::socket::start (std::chrono::steady_clock::time_point timeout_a) +void nano::socket::start (std::chrono::steady_clock::time_point timeout_a) { cutoff = timeout_a.time_since_epoch ().count (); } -void rai::socket::stop () +void nano::socket::stop () { cutoff = std::numeric_limits::max (); } -void rai::socket::close () +void nano::socket::close () { if (socket_m.is_open ()) { @@ -81,9 +81,9 @@ void rai::socket::close () } } -void rai::socket::checkup () +void nano::socket::checkup () { - std::weak_ptr this_w (shared_from_this ()); + std::weak_ptr this_w (shared_from_this ()); node->alarm.add (std::chrono::steady_clock::now () + std::chrono::seconds (10), [this_w]() { if (auto this_l = this_w.lock ()) { @@ -103,9 +103,9 @@ void rai::socket::checkup () }); } -rai::tcp_endpoint rai::socket::remote_endpoint () +nano::tcp_endpoint nano::socket::remote_endpoint () { - rai::tcp_endpoint endpoint; + nano::tcp_endpoint endpoint; if (socket_m.is_open ()) { @@ -117,10 +117,10 @@ rai::tcp_endpoint rai::socket::remote_endpoint () return endpoint; } -rai::bootstrap_client::bootstrap_client (std::shared_ptr node_a, std::shared_ptr attempt_a, rai::tcp_endpoint const & endpoint_a) : +nano::bootstrap_client::bootstrap_client (std::shared_ptr node_a, std::shared_ptr attempt_a, nano::tcp_endpoint const & endpoint_a) : node (node_a), attempt (attempt_a), -socket (std::make_shared (node_a)), +socket (std::make_shared (node_a)), receive_buffer (std::make_shared> ()), endpoint (endpoint_a), start_time (std::chrono::steady_clock::now ()), @@ -132,23 +132,23 @@ hard_stop (false) receive_buffer->resize (256); } -rai::bootstrap_client::~bootstrap_client () +nano::bootstrap_client::~bootstrap_client () { --attempt->connections; } -double rai::bootstrap_client::block_rate () const +double nano::bootstrap_client::block_rate () const { auto elapsed = elapsed_seconds (); return elapsed > 0.0 ? (double)block_count.load () / elapsed : 0.0; } -double rai::bootstrap_client::elapsed_seconds () const +double nano::bootstrap_client::elapsed_seconds () const { return std::chrono::duration_cast> (std::chrono::steady_clock::now () - start_time).count (); } -void rai::bootstrap_client::stop (bool force) +void nano::bootstrap_client::stop (bool force) { pending_stop = true; if (force) @@ -157,7 +157,7 @@ void rai::bootstrap_client::stop (bool force) } } -void rai::bootstrap_client::run () +void nano::bootstrap_client::run () { auto this_l (shared_from_this ()); socket->async_connect (endpoint, [this_l](boost::system::error_code const & ec) { @@ -190,15 +190,15 @@ void rai::bootstrap_client::run () }); } -void rai::frontier_req_client::run () +void nano::frontier_req_client::run () { - std::unique_ptr request (new rai::frontier_req); + std::unique_ptr request (new nano::frontier_req); request->start.clear (); request->age = std::numeric_limitsage)>::max (); request->count = std::numeric_limitscount)>::max (); auto send_buffer (std::make_shared> ()); { - rai::vectorstream stream (*send_buffer); + nano::vectorstream stream (*send_buffer); request->serialize (stream); } auto this_l (shared_from_this ()); @@ -217,12 +217,12 @@ void rai::frontier_req_client::run () }); } -std::shared_ptr rai::bootstrap_client::shared () +std::shared_ptr nano::bootstrap_client::shared () { return shared_from_this (); } -rai::frontier_req_client::frontier_req_client (std::shared_ptr connection_a) : +nano::frontier_req_client::frontier_req_client (std::shared_ptr connection_a) : connection (connection_a), current (0), count (0), @@ -232,14 +232,14 @@ bulk_push_cost (0) next (transaction); } -rai::frontier_req_client::~frontier_req_client () +nano::frontier_req_client::~frontier_req_client () { } -void rai::frontier_req_client::receive_frontier () +void nano::frontier_req_client::receive_frontier () { auto this_l (shared_from_this ()); - size_t size_l (sizeof (rai::uint256_union) + sizeof (rai::uint256_union)); + size_t size_l (sizeof (nano::uint256_union) + sizeof (nano::uint256_union)); connection->socket->async_read (connection->receive_buffer, size_l, [this_l, size_l](boost::system::error_code const & ec, size_t size_a) { // An issue with asio is that sometimes, instead of reporting a bad file descriptor during disconnect, // we simply get a size of 0. @@ -257,7 +257,7 @@ void rai::frontier_req_client::receive_frontier () }); } -void rai::frontier_req_client::unsynced (rai::block_hash const & head, rai::block_hash const & end) +void nano::frontier_req_client::unsynced (nano::block_hash const & head, nano::block_hash const & end) { if (bulk_push_cost < bulk_push_cost_limit) { @@ -273,18 +273,18 @@ void rai::frontier_req_client::unsynced (rai::block_hash const & head, rai::bloc } } -void rai::frontier_req_client::received_frontier (boost::system::error_code const & ec, size_t size_a) +void nano::frontier_req_client::received_frontier (boost::system::error_code const & ec, size_t size_a) { if (!ec) { - assert (size_a == sizeof (rai::uint256_union) + sizeof (rai::uint256_union)); - rai::account account; - rai::bufferstream account_stream (connection->receive_buffer->data (), sizeof (rai::uint256_union)); - auto error1 (rai::read (account_stream, account)); + assert (size_a == sizeof (nano::uint256_union) + sizeof (nano::uint256_union)); + nano::account account; + nano::bufferstream account_stream (connection->receive_buffer->data (), sizeof (nano::uint256_union)); + auto error1 (nano::read (account_stream, account)); assert (!error1); - rai::block_hash latest; - rai::bufferstream latest_stream (connection->receive_buffer->data () + sizeof (rai::uint256_union), sizeof (rai::uint256_union)); - auto error2 (rai::read (latest_stream, latest)); + nano::block_hash latest; + nano::bufferstream latest_stream (connection->receive_buffer->data () + sizeof (nano::uint256_union), sizeof (nano::uint256_union)); + auto error2 (nano::read (latest_stream, latest)); assert (!error2); if (count == 0) { @@ -330,7 +330,7 @@ void rai::frontier_req_client::received_frontier (boost::system::error_code cons } else { - connection->attempt->add_pull (rai::pull_info (account, latest, frontier)); + connection->attempt->add_pull (nano::pull_info (account, latest, frontier)); // Either we're behind or there's a fork we differ on // Either way, bulk pushing will probably not be effective bulk_push_cost += 5; @@ -341,12 +341,12 @@ void rai::frontier_req_client::received_frontier (boost::system::error_code cons else { assert (account < current); - connection->attempt->add_pull (rai::pull_info (account, latest, rai::block_hash (0))); + connection->attempt->add_pull (nano::pull_info (account, latest, nano::block_hash (0))); } } else { - connection->attempt->add_pull (rai::pull_info (account, latest, rai::block_hash (0))); + connection->attempt->add_pull (nano::pull_info (account, latest, nano::block_hash (0))); } receive_frontier (); } @@ -383,7 +383,7 @@ void rai::frontier_req_client::received_frontier (boost::system::error_code cons } } -void rai::frontier_req_client::next (rai::transaction const & transaction_a) +void nano::frontier_req_client::next (nano::transaction const & transaction_a) { // Filling accounts deque to prevent often read transactions if (accounts.empty ()) @@ -391,14 +391,14 @@ void rai::frontier_req_client::next (rai::transaction const & transaction_a) size_t max_size (128); for (auto i (connection->node->store.latest_begin (transaction_a, current.number () + 1)), n (connection->node->store.latest_end ()); i != n && accounts.size () != max_size; ++i) { - rai::account_info info (i->second); - accounts.push_back (std::make_pair (rai::account (i->first), info.head)); + nano::account_info info (i->second); + accounts.push_back (std::make_pair (nano::account (i->first), info.head)); } /* If loop breaks before max_size, then latest_end () is reached Add empty record to finish frontier_req_server */ if (accounts.size () != max_size) { - accounts.push_back (std::make_pair (rai::account (0), rai::block_hash (0))); + accounts.push_back (std::make_pair (nano::account (0), nano::block_hash (0))); } } // Retrieving accounts from deque @@ -408,7 +408,7 @@ void rai::frontier_req_client::next (rai::transaction const & transaction_a) frontier = account_pair.second; } -rai::bulk_pull_client::bulk_pull_client (std::shared_ptr connection_a, rai::pull_info const & pull_a) : +nano::bulk_pull_client::bulk_pull_client (std::shared_ptr connection_a, nano::pull_info const & pull_a) : connection (connection_a), pull (pull_a), total_blocks (0) @@ -417,7 +417,7 @@ total_blocks (0) connection->attempt->condition.notify_all (); } -rai::bulk_pull_client::~bulk_pull_client () +nano::bulk_pull_client::~bulk_pull_client () { // If received end block is not expected end block if (expected != pull.end) @@ -440,10 +440,10 @@ rai::bulk_pull_client::~bulk_pull_client () connection->attempt->condition.notify_all (); } -void rai::bulk_pull_client::request () +void nano::bulk_pull_client::request () { expected = pull.head; - rai::bulk_pull req; + nano::bulk_pull req; req.start = pull.account; req.end = pull.end; req.count = pull.count; @@ -451,7 +451,7 @@ void rai::bulk_pull_client::request () auto buffer (std::make_shared> ()); { - rai::vectorstream stream (*buffer); + nano::vectorstream stream (*buffer); req.serialize (stream); } if (connection->node->config.logging.bulk_pull_logging ()) @@ -480,7 +480,7 @@ void rai::bulk_pull_client::request () }); } -void rai::bulk_pull_client::receive_block () +void nano::bulk_pull_client::receive_block () { auto this_l (shared_from_this ()); connection->socket->async_read (connection->receive_buffer, 1, [this_l](boost::system::error_code const & ec, size_t size_a) { @@ -498,48 +498,48 @@ void rai::bulk_pull_client::receive_block () }); } -void rai::bulk_pull_client::received_type () +void nano::bulk_pull_client::received_type () { auto this_l (shared_from_this ()); - rai::block_type type (static_cast (connection->receive_buffer->data ()[0])); + nano::block_type type (static_cast (connection->receive_buffer->data ()[0])); switch (type) { - case rai::block_type::send: + case nano::block_type::send: { - connection->socket->async_read (connection->receive_buffer, rai::send_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_read (connection->receive_buffer, nano::send_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { this_l->received_block (ec, size_a, type); }); break; } - case rai::block_type::receive: + case nano::block_type::receive: { - connection->socket->async_read (connection->receive_buffer, rai::receive_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_read (connection->receive_buffer, nano::receive_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { this_l->received_block (ec, size_a, type); }); break; } - case rai::block_type::open: + case nano::block_type::open: { - connection->socket->async_read (connection->receive_buffer, rai::open_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_read (connection->receive_buffer, nano::open_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { this_l->received_block (ec, size_a, type); }); break; } - case rai::block_type::change: + case nano::block_type::change: { - connection->socket->async_read (connection->receive_buffer, rai::change_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_read (connection->receive_buffer, nano::change_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { this_l->received_block (ec, size_a, type); }); break; } - case rai::block_type::state: + case nano::block_type::state: { - connection->socket->async_read (connection->receive_buffer, rai::state_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_read (connection->receive_buffer, nano::state_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { this_l->received_block (ec, size_a, type); }); break; } - case rai::block_type::not_a_block: + case nano::block_type::not_a_block: { // Avoid re-using slow peers, or peers that sent the wrong blocks. if (!connection->pending_stop && expected == pull.end) @@ -559,13 +559,13 @@ void rai::bulk_pull_client::received_type () } } -void rai::bulk_pull_client::received_block (boost::system::error_code const & ec, size_t size_a, rai::block_type type_a) +void nano::bulk_pull_client::received_block (boost::system::error_code const & ec, size_t size_a, nano::block_type type_a) { if (!ec) { - rai::bufferstream stream (connection->receive_buffer->data (), size_a); - std::shared_ptr block (rai::deserialize_block (stream, type_a)); - if (block != nullptr && !rai::work_validate (*block)) + nano::bufferstream stream (connection->receive_buffer->data (), size_a); + std::shared_ptr block (nano::deserialize_block (stream, type_a)); + if (block != nullptr && !nano::work_validate (*block)) { auto hash (block->hash ()); if (connection->node->config.logging.bulk_pull_logging ()) @@ -618,21 +618,21 @@ void rai::bulk_pull_client::received_block (boost::system::error_code const & ec } } -rai::bulk_push_client::bulk_push_client (std::shared_ptr const & connection_a) : +nano::bulk_push_client::bulk_push_client (std::shared_ptr const & connection_a) : connection (connection_a) { } -rai::bulk_push_client::~bulk_push_client () +nano::bulk_push_client::~bulk_push_client () { } -void rai::bulk_push_client::start () +void nano::bulk_push_client::start () { - rai::bulk_push message; + nano::bulk_push message; auto buffer (std::make_shared> ()); { - rai::vectorstream stream (*buffer); + nano::vectorstream stream (*buffer); message.serialize (stream); } auto this_l (shared_from_this ()); @@ -652,9 +652,9 @@ void rai::bulk_push_client::start () }); } -void rai::bulk_push_client::push (rai::transaction const & transaction_a) +void nano::bulk_push_client::push (nano::transaction const & transaction_a) { - std::shared_ptr block; + std::shared_ptr block; bool finished (false); while (block == nullptr && !finished) { @@ -676,7 +676,7 @@ void rai::bulk_push_client::push (rai::transaction const & transaction_a) block = connection->node->store.block_get (transaction_a, current_target.first); if (block == nullptr) { - current_target.first = rai::block_hash (0); + current_target.first = nano::block_hash (0); } else { @@ -698,11 +698,11 @@ void rai::bulk_push_client::push (rai::transaction const & transaction_a) } } -void rai::bulk_push_client::send_finished () +void nano::bulk_push_client::send_finished () { auto buffer (std::make_shared> ()); - buffer->push_back (static_cast (rai::block_type::not_a_block)); - connection->node->stats.inc (rai::stat::type::bootstrap, rai::stat::detail::bulk_push, rai::stat::dir::out); + buffer->push_back (static_cast (nano::block_type::not_a_block)); + connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_push, nano::stat::dir::out); if (connection->node->config.logging.network_logging ()) { BOOST_LOG (connection->node->log) << "Bulk push finished"; @@ -719,12 +719,12 @@ void rai::bulk_push_client::send_finished () }); } -void rai::bulk_push_client::push_block (rai::block const & block_a) +void nano::bulk_push_client::push_block (nano::block const & block_a) { auto buffer (std::make_shared> ()); { - rai::vectorstream stream (*buffer); - rai::serialize_block (stream, block_a); + nano::vectorstream stream (*buffer); + nano::serialize_block (stream, block_a); } auto this_l (shared_from_this ()); connection->socket->async_write (buffer, [this_l](boost::system::error_code const & ec, size_t size_a) { @@ -743,7 +743,7 @@ void rai::bulk_push_client::push_block (rai::block const & block_a) }); } -rai::pull_info::pull_info () : +nano::pull_info::pull_info () : account (0), end (0), count (0), @@ -751,7 +751,7 @@ attempts (0) { } -rai::pull_info::pull_info (rai::account const & account_a, rai::block_hash const & head_a, rai::block_hash const & end_a, count_t count_a) : +nano::pull_info::pull_info (nano::account const & account_a, nano::block_hash const & head_a, nano::block_hash const & end_a, count_t count_a) : account (account_a), head (head_a), end (end_a), @@ -760,7 +760,7 @@ attempts (0) { } -rai::bootstrap_attempt::bootstrap_attempt (std::shared_ptr node_a) : +nano::bootstrap_attempt::bootstrap_attempt (std::shared_ptr node_a) : next_log (std::chrono::steady_clock::now ()), connections (0), pulling (0), @@ -775,13 +775,13 @@ lazy_stopped (0) node->bootstrap_initiator.notify_listeners (true); } -rai::bootstrap_attempt::~bootstrap_attempt () +nano::bootstrap_attempt::~bootstrap_attempt () { BOOST_LOG (node->log) << "Exiting bootstrap attempt"; node->bootstrap_initiator.notify_listeners (false); } -bool rai::bootstrap_attempt::should_log () +bool nano::bootstrap_attempt::should_log () { std::lock_guard lock (mutex); auto result (false); @@ -794,7 +794,7 @@ bool rai::bootstrap_attempt::should_log () return result; } -bool rai::bootstrap_attempt::request_frontier (std::unique_lock & lock_a) +bool nano::bootstrap_attempt::request_frontier (std::unique_lock & lock_a) { auto result (true); auto connection_l (connection (lock_a)); @@ -803,7 +803,7 @@ bool rai::bootstrap_attempt::request_frontier (std::unique_lock & lo { std::future future; { - auto client (std::make_shared (connection_l)); + auto client (std::make_shared (connection_l)); client->run (); frontiers = client; future = client->promise.get_future (); @@ -830,7 +830,7 @@ bool rai::bootstrap_attempt::request_frontier (std::unique_lock & lo return result; } -void rai::bootstrap_attempt::request_pull (std::unique_lock & lock_a) +void nano::bootstrap_attempt::request_pull (std::unique_lock & lock_a) { auto connection_l (connection (lock_a)); if (connection_l) @@ -851,20 +851,20 @@ void rai::bootstrap_attempt::request_pull (std::unique_lock & lock_a // The bulk_pull_client destructor attempt to requeue_pull which can cause a deadlock if this is the last reference // Dispatch request in an external thread in case it needs to be destroyed node->background ([connection_l, pull]() { - auto client (std::make_shared (connection_l, pull)); + auto client (std::make_shared (connection_l, pull)); client->request (); }); } } -void rai::bootstrap_attempt::request_push (std::unique_lock & lock_a) +void nano::bootstrap_attempt::request_push (std::unique_lock & lock_a) { bool error (false); if (auto connection_shared = connection_frontier_request.lock ()) { std::future future; { - auto client (std::make_shared (connection_shared)); + auto client (std::make_shared (connection_shared)); client->start (); push = client; future = client->promise.get_future (); @@ -883,7 +883,7 @@ void rai::bootstrap_attempt::request_push (std::unique_lock & lock_a } } -bool rai::bootstrap_attempt::still_pulling () +bool nano::bootstrap_attempt::still_pulling () { assert (!mutex.try_lock ()); auto running (!stopped); @@ -892,7 +892,7 @@ bool rai::bootstrap_attempt::still_pulling () return running && (more_pulls || still_pulling); } -void rai::bootstrap_attempt::run () +void nano::bootstrap_attempt::run () { populate_connections (); std::unique_lock lock (mutex); @@ -904,7 +904,7 @@ void rai::bootstrap_attempt::run () // Shuffle pulls. for (int i = pulls.size () - 1; i > 0; i--) { - auto k = rai::random_pool.GenerateWord32 (0, i); + auto k = nano::random_pool.GenerateWord32 (0, i); std::swap (pulls[i], pulls[k]); } while (still_pulling ()) @@ -952,13 +952,13 @@ void rai::bootstrap_attempt::run () idle.clear (); } -std::shared_ptr rai::bootstrap_attempt::connection (std::unique_lock & lock_a) +std::shared_ptr nano::bootstrap_attempt::connection (std::unique_lock & lock_a) { while (!stopped && idle.empty ()) { condition.wait (lock_a); } - std::shared_ptr result; + std::shared_ptr result; if (!idle.empty ()) { result = idle.back (); @@ -967,7 +967,7 @@ std::shared_ptr rai::bootstrap_attempt::connection (std:: return result; } -bool rai::bootstrap_attempt::consume_future (std::future & future_a) +bool nano::bootstrap_attempt::consume_future (std::future & future_a) { bool result; try @@ -983,13 +983,13 @@ bool rai::bootstrap_attempt::consume_future (std::future & future_a) struct block_rate_cmp { - bool operator() (const std::shared_ptr & lhs, const std::shared_ptr & rhs) const + bool operator() (const std::shared_ptr & lhs, const std::shared_ptr & rhs) const { return lhs->block_rate () > rhs->block_rate (); } }; -unsigned rai::bootstrap_attempt::target_connections (size_t pulls_remaining) +unsigned nano::bootstrap_attempt::target_connections (size_t pulls_remaining) { if (node->config.bootstrap_connections >= node->config.bootstrap_connections_max) { @@ -1002,11 +1002,11 @@ unsigned rai::bootstrap_attempt::target_connections (size_t pulls_remaining) return std::max (1U, (unsigned)(target + 0.5f)); } -void rai::bootstrap_attempt::populate_connections () +void nano::bootstrap_attempt::populate_connections () { double rate_sum = 0.0; size_t num_pulls = 0; - std::priority_queue, std::vector>, block_rate_cmp> sorted_connections; + std::priority_queue, std::vector>, block_rate_cmp> sorted_connections; { std::unique_lock lock (mutex); num_pulls = pulls.size (); @@ -1078,9 +1078,9 @@ void rai::bootstrap_attempt::populate_connections () for (int i = 0; i < delta; i++) { auto peer (node->peers.bootstrap_peer ()); - if (peer != rai::endpoint (boost::asio::ip::address_v6::any (), 0)) + if (peer != nano::endpoint (boost::asio::ip::address_v6::any (), 0)) { - auto client (std::make_shared (node, shared_from_this (), rai::tcp_endpoint (peer.address (), peer.port ()))); + auto client (std::make_shared (node, shared_from_this (), nano::tcp_endpoint (peer.address (), peer.port ()))); client->run (); std::lock_guard lock (mutex); clients.push_back (client); @@ -1095,7 +1095,7 @@ void rai::bootstrap_attempt::populate_connections () } if (!stopped) { - std::weak_ptr this_w (shared_from_this ()); + std::weak_ptr this_w (shared_from_this ()); node->alarm.add (std::chrono::steady_clock::now () + std::chrono::seconds (1), [this_w]() { if (auto this_l = this_w.lock ()) { @@ -1105,13 +1105,13 @@ void rai::bootstrap_attempt::populate_connections () } } -void rai::bootstrap_attempt::add_connection (rai::endpoint const & endpoint_a) +void nano::bootstrap_attempt::add_connection (nano::endpoint const & endpoint_a) { - auto client (std::make_shared (node, shared_from_this (), rai::tcp_endpoint (endpoint_a.address (), endpoint_a.port ()))); + auto client (std::make_shared (node, shared_from_this (), nano::tcp_endpoint (endpoint_a.address (), endpoint_a.port ()))); client->run (); } -void rai::bootstrap_attempt::pool_connection (std::shared_ptr client_a) +void nano::bootstrap_attempt::pool_connection (std::shared_ptr client_a) { { std::lock_guard lock (mutex); @@ -1120,7 +1120,7 @@ void rai::bootstrap_attempt::pool_connection (std::shared_ptr lock (mutex); stopped = true; @@ -1154,7 +1154,7 @@ void rai::bootstrap_attempt::stop () } } -void rai::bootstrap_attempt::add_pull (rai::pull_info const & pull) +void nano::bootstrap_attempt::add_pull (nano::pull_info const & pull) { { std::lock_guard lock (mutex); @@ -1163,7 +1163,7 @@ void rai::bootstrap_attempt::add_pull (rai::pull_info const & pull) condition.notify_all (); } -void rai::bootstrap_attempt::requeue_pull (rai::pull_info const & pull_a) +void nano::bootstrap_attempt::requeue_pull (nano::pull_info const & pull_a) { auto pull (pull_a); if (++pull.attempts < bootstrap_frontier_retry_limit) @@ -1191,13 +1191,13 @@ void rai::bootstrap_attempt::requeue_pull (rai::pull_info const & pull_a) } } -void rai::bootstrap_attempt::add_bulk_push_target (rai::block_hash const & head, rai::block_hash const & end) +void nano::bootstrap_attempt::add_bulk_push_target (nano::block_hash const & head, nano::block_hash const & end) { std::lock_guard lock (mutex); bulk_push_targets.push_back (std::make_pair (head, end)); } -void rai::bootstrap_attempt::lazy_start (rai::block_hash const & hash_a) +void nano::bootstrap_attempt::lazy_start (nano::block_hash const & hash_a) { std::unique_lock lock (lazy_mutex); // Add start blocks, limit 1024 (32k with disabled legacy bootstrap) @@ -1209,7 +1209,7 @@ void rai::bootstrap_attempt::lazy_start (rai::block_hash const & hash_a) } } -void rai::bootstrap_attempt::lazy_add (rai::block_hash const & hash_a) +void nano::bootstrap_attempt::lazy_add (nano::block_hash const & hash_a) { // Add only unknown blocks assert (!lazy_mutex.try_lock ()); @@ -1219,7 +1219,7 @@ void rai::bootstrap_attempt::lazy_add (rai::block_hash const & hash_a) } } -void rai::bootstrap_attempt::lazy_pull_flush () +void nano::bootstrap_attempt::lazy_pull_flush () { std::unique_lock lock (lazy_mutex); for (auto & pull_start : lazy_pulls) @@ -1227,13 +1227,13 @@ void rai::bootstrap_attempt::lazy_pull_flush () // Recheck if block was already processed if (lazy_blocks.find (pull_start) == lazy_blocks.end ()) { - add_pull (rai::pull_info (pull_start, pull_start, rai::block_hash (0), lazy_max_pull_blocks)); + add_pull (nano::pull_info (pull_start, pull_start, nano::block_hash (0), lazy_max_pull_blocks)); } } lazy_pulls.clear (); } -bool rai::bootstrap_attempt::lazy_finished () +bool nano::bootstrap_attempt::lazy_finished () { bool result (true); auto transaction (node->store.tx_begin_read ()); @@ -1260,7 +1260,7 @@ bool rai::bootstrap_attempt::lazy_finished () return result; } -void rai::bootstrap_attempt::lazy_run () +void nano::bootstrap_attempt::lazy_run () { populate_connections (); auto start_time (std::chrono::steady_clock::now ()); @@ -1328,7 +1328,7 @@ void rai::bootstrap_attempt::lazy_run () idle.clear (); } -bool rai::bootstrap_attempt::process_block (std::shared_ptr block_a, uint64_t total_blocks, bool block_expected) +bool nano::bootstrap_attempt::process_block (std::shared_ptr block_a, uint64_t total_blocks, bool block_expected) { bool stop_pull (false); if (lazy_mode && block_expected) @@ -1342,33 +1342,33 @@ bool rai::bootstrap_attempt::process_block (std::shared_ptr block_a, auto transaction (node->store.tx_begin_read ()); if (!node->store.block_exists (transaction, block_a->type (), hash)) { - rai::uint128_t balance (std::numeric_limits::max ()); + nano::uint128_t balance (std::numeric_limits::max ()); node->block_processor.add (block_a, std::chrono::steady_clock::time_point ()); // Search for new dependencies if (!block_a->source ().is_zero () && !node->store.block_exists (transaction, block_a->source ())) { lazy_add (block_a->source ()); } - else if (block_a->type () == rai::block_type::send) + else if (block_a->type () == nano::block_type::send) { // Calculate balance for legacy send blocks - std::shared_ptr block_l (std::static_pointer_cast (block_a)); + std::shared_ptr block_l (std::static_pointer_cast (block_a)); if (block_l != nullptr) { balance = block_l->hashables.balance.number (); } } - else if (block_a->type () == rai::block_type::state) + else if (block_a->type () == nano::block_type::state) { - std::shared_ptr block_l (std::static_pointer_cast (block_a)); + std::shared_ptr block_l (std::static_pointer_cast (block_a)); if (block_l != nullptr) { balance = block_l->hashables.balance.number (); - rai::block_hash link (block_l->hashables.link); + nano::block_hash link (block_l->hashables.link); // If link is not epoch link or 0. And if block from link unknown if (!link.is_zero () && link != node->ledger.epoch_link && lazy_blocks.find (link) == lazy_blocks.end () && !node->store.block_exists (transaction, link)) { - rai::block_hash previous (block_l->hashables.previous); + nano::block_hash previous (block_l->hashables.previous); // If state block previous is 0 then source block required if (previous.is_zero ()) { @@ -1377,7 +1377,7 @@ bool rai::bootstrap_attempt::process_block (std::shared_ptr block_a, // In other cases previous block balance required to find out subtype of state block else if (node->store.block_exists (transaction, previous)) { - rai::amount prev_balance (node->ledger.balance (transaction, previous)); + nano::amount prev_balance (node->ledger.balance (transaction, previous)); if (prev_balance.number () <= balance) { lazy_add (link); @@ -1434,18 +1434,18 @@ bool rai::bootstrap_attempt::process_block (std::shared_ptr block_a, auto next_block (find_state->second); lazy_state_unknown.erase (hash); // Retrieve balance for previous state blocks - if (block_a->type () == rai::block_type::state) + if (block_a->type () == nano::block_type::state) { - std::shared_ptr block_l (std::static_pointer_cast (block_a)); + std::shared_ptr block_l (std::static_pointer_cast (block_a)); if (block_l->hashables.balance.number () <= next_block.second) { lazy_add (next_block.first); } } // Retrieve balance for previous legacy send blocks - else if (block_a->type () == rai::block_type::send) + else if (block_a->type () == nano::block_type::send) { - std::shared_ptr block_l (std::static_pointer_cast (block_a)); + std::shared_ptr block_l (std::static_pointer_cast (block_a)); if (block_l->hashables.balance.number () <= next_block.second) { lazy_add (next_block.first); @@ -1482,38 +1482,38 @@ bool rai::bootstrap_attempt::process_block (std::shared_ptr block_a, return stop_pull; } -rai::bootstrap_initiator::bootstrap_initiator (rai::node & node_a) : +nano::bootstrap_initiator::bootstrap_initiator (nano::node & node_a) : node (node_a), stopped (false), thread ([this]() { - rai::thread_role::set (rai::thread_role::name::bootstrap_initiator); + nano::thread_role::set (nano::thread_role::name::bootstrap_initiator); run_bootstrap (); }) { } -rai::bootstrap_initiator::~bootstrap_initiator () +nano::bootstrap_initiator::~bootstrap_initiator () { stop (); thread.join (); } -void rai::bootstrap_initiator::bootstrap () +void nano::bootstrap_initiator::bootstrap () { std::unique_lock lock (mutex); if (!stopped && attempt == nullptr) { - node.stats.inc (rai::stat::type::bootstrap, rai::stat::detail::initiate, rai::stat::dir::out); - attempt = std::make_shared (node.shared ()); + node.stats.inc (nano::stat::type::bootstrap, nano::stat::detail::initiate, nano::stat::dir::out); + attempt = std::make_shared (node.shared ()); condition.notify_all (); } } -void rai::bootstrap_initiator::bootstrap (rai::endpoint const & endpoint_a, bool add_to_peers) +void nano::bootstrap_initiator::bootstrap (nano::endpoint const & endpoint_a, bool add_to_peers) { if (add_to_peers) { - node.peers.insert (rai::map_endpoint_to_v6 (endpoint_a), rai::protocol_version); + node.peers.insert (nano::map_endpoint_to_v6 (endpoint_a), nano::protocol_version); } std::unique_lock lock (mutex); if (!stopped) @@ -1523,14 +1523,14 @@ void rai::bootstrap_initiator::bootstrap (rai::endpoint const & endpoint_a, bool attempt->stop (); condition.wait (lock); } - node.stats.inc (rai::stat::type::bootstrap, rai::stat::detail::initiate, rai::stat::dir::out); - attempt = std::make_shared (node.shared ()); + node.stats.inc (nano::stat::type::bootstrap, nano::stat::detail::initiate, nano::stat::dir::out); + attempt = std::make_shared (node.shared ()); attempt->add_connection (endpoint_a); condition.notify_all (); } } -void rai::bootstrap_initiator::bootstrap_lazy (rai::block_hash const & hash_a, bool force) +void nano::bootstrap_initiator::bootstrap_lazy (nano::block_hash const & hash_a, bool force) { { std::unique_lock lock (mutex); @@ -1542,10 +1542,10 @@ void rai::bootstrap_initiator::bootstrap_lazy (rai::block_hash const & hash_a, b condition.wait (lock); } } - node.stats.inc (rai::stat::type::bootstrap, rai::stat::detail::initiate_lazy, rai::stat::dir::out); + node.stats.inc (nano::stat::type::bootstrap, nano::stat::detail::initiate_lazy, nano::stat::dir::out); if (attempt == nullptr) { - attempt = std::make_shared (node.shared ()); + attempt = std::make_shared (node.shared ()); attempt->lazy_mode = true; } attempt->lazy_start (hash_a); @@ -1553,7 +1553,7 @@ void rai::bootstrap_initiator::bootstrap_lazy (rai::block_hash const & hash_a, b condition.notify_all (); } -void rai::bootstrap_initiator::run_bootstrap () +void nano::bootstrap_initiator::run_bootstrap () { std::unique_lock lock (mutex); while (!stopped) @@ -1580,24 +1580,24 @@ void rai::bootstrap_initiator::run_bootstrap () } } -void rai::bootstrap_initiator::add_observer (std::function const & observer_a) +void nano::bootstrap_initiator::add_observer (std::function const & observer_a) { std::lock_guard lock (mutex); observers.push_back (observer_a); } -bool rai::bootstrap_initiator::in_progress () +bool nano::bootstrap_initiator::in_progress () { return current_attempt () != nullptr; } -std::shared_ptr rai::bootstrap_initiator::current_attempt () +std::shared_ptr nano::bootstrap_initiator::current_attempt () { std::lock_guard lock (mutex); return attempt; } -void rai::bootstrap_initiator::stop () +void nano::bootstrap_initiator::stop () { { std::unique_lock lock (mutex); @@ -1610,7 +1610,7 @@ void rai::bootstrap_initiator::stop () condition.notify_all (); } -void rai::bootstrap_initiator::notify_listeners (bool in_progress_a) +void nano::bootstrap_initiator::notify_listeners (bool in_progress_a) { for (auto & i : observers) { @@ -1618,7 +1618,7 @@ void rai::bootstrap_initiator::notify_listeners (bool in_progress_a) } } -rai::bootstrap_listener::bootstrap_listener (boost::asio::io_context & io_ctx_a, uint16_t port_a, rai::node & node_a) : +nano::bootstrap_listener::bootstrap_listener (boost::asio::io_context & io_ctx_a, uint16_t port_a, nano::node & node_a) : acceptor (io_ctx_a), local (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v6::any (), port_a)), io_ctx (io_ctx_a), @@ -1626,7 +1626,7 @@ node (node_a) { } -void rai::bootstrap_listener::start () +void nano::bootstrap_listener::start () { acceptor.open (local.protocol ()); acceptor.set_option (boost::asio::ip::tcp::acceptor::reuse_address (true)); @@ -1643,7 +1643,7 @@ void rai::bootstrap_listener::start () accept_connection (); } -void rai::bootstrap_listener::stop () +void nano::bootstrap_listener::stop () { decltype (connections) connections_l; { @@ -1662,20 +1662,20 @@ void rai::bootstrap_listener::stop () } } -void rai::bootstrap_listener::accept_connection () +void nano::bootstrap_listener::accept_connection () { - auto socket (std::make_shared (node.shared ())); + auto socket (std::make_shared (node.shared ())); acceptor.async_accept (socket->socket_m, [this, socket](boost::system::error_code const & ec) { accept_action (ec, socket); }); } -void rai::bootstrap_listener::accept_action (boost::system::error_code const & ec, std::shared_ptr socket_a) +void nano::bootstrap_listener::accept_action (boost::system::error_code const & ec, std::shared_ptr socket_a) { if (!ec) { accept_connection (); - auto connection (std::make_shared (socket_a, node.shared ())); + auto connection (std::make_shared (socket_a, node.shared ())); { std::lock_guard lock (mutex); if (connections.size () < node.config.bootstrap_connections_max && acceptor.is_open ()) @@ -1691,12 +1691,12 @@ void rai::bootstrap_listener::accept_action (boost::system::error_code const & e } } -boost::asio::ip::tcp::endpoint rai::bootstrap_listener::endpoint () +boost::asio::ip::tcp::endpoint nano::bootstrap_listener::endpoint () { return boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v6::loopback (), local.port ()); } -rai::bootstrap_server::~bootstrap_server () +nano::bootstrap_server::~bootstrap_server () { if (node->config.logging.bulk_pull_logging ()) { @@ -1706,7 +1706,7 @@ rai::bootstrap_server::~bootstrap_server () node->bootstrap.connections.erase (this); } -rai::bootstrap_server::bootstrap_server (std::shared_ptr socket_a, std::shared_ptr node_a) : +nano::bootstrap_server::bootstrap_server (std::shared_ptr socket_a, std::shared_ptr node_a) : receive_buffer (std::make_shared> ()), socket (socket_a), node (node_a) @@ -1714,7 +1714,7 @@ node (node_a) receive_buffer->resize (128); } -void rai::bootstrap_server::receive () +void nano::bootstrap_server::receive () { auto this_l (shared_from_this ()); socket->async_read (receive_buffer, 8, [this_l](boost::system::error_code const & ec, size_t size_a) { @@ -1722,26 +1722,26 @@ void rai::bootstrap_server::receive () }); } -void rai::bootstrap_server::receive_header_action (boost::system::error_code const & ec, size_t size_a) +void nano::bootstrap_server::receive_header_action (boost::system::error_code const & ec, size_t size_a) { if (!ec) { assert (size_a == 8); - rai::bufferstream type_stream (receive_buffer->data (), size_a); + nano::bufferstream type_stream (receive_buffer->data (), size_a); auto error (false); - rai::message_header header (error, type_stream); + nano::message_header header (error, type_stream); if (!error) { switch (header.type) { - case rai::message_type::bulk_pull: + case nano::message_type::bulk_pull: { uint32_t extended_size; - node->stats.inc (rai::stat::type::bootstrap, rai::stat::detail::bulk_pull, rai::stat::dir::in); + node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull, nano::stat::dir::in); if (header.bulk_pull_is_count_present ()) { - extended_size = rai::bulk_pull::extended_parameters_size; + extended_size = nano::bulk_pull::extended_parameters_size; } else { @@ -1749,21 +1749,21 @@ void rai::bootstrap_server::receive_header_action (boost::system::error_code con } auto this_l (shared_from_this ()); - socket->async_read (receive_buffer, sizeof (rai::uint256_union) + sizeof (rai::uint256_union) + extended_size, [this_l, header](boost::system::error_code const & ec, size_t size_a) { + socket->async_read (receive_buffer, sizeof (nano::uint256_union) + sizeof (nano::uint256_union) + extended_size, [this_l, header](boost::system::error_code const & ec, size_t size_a) { this_l->receive_bulk_pull_action (ec, size_a, header); }); break; } - case rai::message_type::bulk_pull_account: + case nano::message_type::bulk_pull_account: { - node->stats.inc (rai::stat::type::bootstrap, rai::stat::detail::bulk_pull_account, rai::stat::dir::in); + node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_account, nano::stat::dir::in); auto this_l (shared_from_this ()); - socket->async_read (receive_buffer, sizeof (rai::uint256_union) + sizeof (rai::uint128_union) + sizeof (uint8_t), [this_l, header](boost::system::error_code const & ec, size_t size_a) { + socket->async_read (receive_buffer, sizeof (nano::uint256_union) + sizeof (nano::uint128_union) + sizeof (uint8_t), [this_l, header](boost::system::error_code const & ec, size_t size_a) { this_l->receive_bulk_pull_account_action (ec, size_a, header); }); break; } - case rai::message_type::bulk_pull_blocks: + case nano::message_type::bulk_pull_blocks: { if (node->config.logging.network_logging ()) { @@ -1771,24 +1771,24 @@ void rai::bootstrap_server::receive_header_action (boost::system::error_code con } auto this_l (shared_from_this ()); - socket->async_read (receive_buffer, sizeof (rai::uint256_union) + sizeof (rai::uint256_union) + sizeof (bulk_pull_blocks_mode) + sizeof (uint32_t), [this_l, header](boost::system::error_code const & ec, size_t size_a) { + socket->async_read (receive_buffer, sizeof (nano::uint256_union) + sizeof (nano::uint256_union) + sizeof (bulk_pull_blocks_mode) + sizeof (uint32_t), [this_l, header](boost::system::error_code const & ec, size_t size_a) { this_l->receive_bulk_pull_blocks_action (ec, size_a, header); }); break; } - case rai::message_type::frontier_req: + case nano::message_type::frontier_req: { - node->stats.inc (rai::stat::type::bootstrap, rai::stat::detail::frontier_req, rai::stat::dir::in); + node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::frontier_req, nano::stat::dir::in); auto this_l (shared_from_this ()); - socket->async_read (receive_buffer, sizeof (rai::uint256_union) + sizeof (uint32_t) + sizeof (uint32_t), [this_l, header](boost::system::error_code const & ec, size_t size_a) { + socket->async_read (receive_buffer, sizeof (nano::uint256_union) + sizeof (uint32_t) + sizeof (uint32_t), [this_l, header](boost::system::error_code const & ec, size_t size_a) { this_l->receive_frontier_req_action (ec, size_a, header); }); break; } - case rai::message_type::bulk_push: + case nano::message_type::bulk_push: { - node->stats.inc (rai::stat::type::bootstrap, rai::stat::detail::bulk_push, rai::stat::dir::in); - add_request (std::unique_ptr (new rai::bulk_push (header))); + node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_push, nano::stat::dir::in); + add_request (std::unique_ptr (new nano::bulk_push (header))); break; } default: @@ -1811,78 +1811,78 @@ void rai::bootstrap_server::receive_header_action (boost::system::error_code con } } -void rai::bootstrap_server::receive_bulk_pull_action (boost::system::error_code const & ec, size_t size_a, rai::message_header const & header_a) +void nano::bootstrap_server::receive_bulk_pull_action (boost::system::error_code const & ec, size_t size_a, nano::message_header const & header_a) { if (!ec) { auto error (false); - rai::bufferstream stream (receive_buffer->data (), size_a); - std::unique_ptr request (new rai::bulk_pull (error, stream, header_a)); + nano::bufferstream stream (receive_buffer->data (), size_a); + std::unique_ptr request (new nano::bulk_pull (error, stream, header_a)); if (!error) { if (node->config.logging.bulk_pull_logging ()) { BOOST_LOG (node->log) << boost::str (boost::format ("Received bulk pull for %1% down to %2%, maximum of %3%") % request->start.to_string () % request->end.to_string () % (request->count ? request->count : std::numeric_limits::infinity ())); } - add_request (std::unique_ptr (request.release ())); + add_request (std::unique_ptr (request.release ())); receive (); } } } -void rai::bootstrap_server::receive_bulk_pull_account_action (boost::system::error_code const & ec, size_t size_a, rai::message_header const & header_a) +void nano::bootstrap_server::receive_bulk_pull_account_action (boost::system::error_code const & ec, size_t size_a, nano::message_header const & header_a) { if (!ec) { auto error (false); - assert (size_a == (sizeof (rai::uint256_union) + sizeof (rai::uint128_union) + sizeof (uint8_t))); - rai::bufferstream stream (receive_buffer->data (), size_a); - std::unique_ptr request (new rai::bulk_pull_account (error, stream, header_a)); + assert (size_a == (sizeof (nano::uint256_union) + sizeof (nano::uint128_union) + sizeof (uint8_t))); + nano::bufferstream stream (receive_buffer->data (), size_a); + std::unique_ptr request (new nano::bulk_pull_account (error, stream, header_a)); if (!error) { if (node->config.logging.bulk_pull_logging ()) { - BOOST_LOG (node->log) << boost::str (boost::format ("Received bulk pull account for %1% with a minimum amount of %2%") % request->account.to_account () % rai::amount (request->minimum_amount).format_balance (rai::Mxrb_ratio, 10, true)); + BOOST_LOG (node->log) << boost::str (boost::format ("Received bulk pull account for %1% with a minimum amount of %2%") % request->account.to_account () % nano::amount (request->minimum_amount).format_balance (nano::Mxrb_ratio, 10, true)); } - add_request (std::unique_ptr (request.release ())); + add_request (std::unique_ptr (request.release ())); receive (); } } } -void rai::bootstrap_server::receive_bulk_pull_blocks_action (boost::system::error_code const & ec, size_t size_a, rai::message_header const & header_a) +void nano::bootstrap_server::receive_bulk_pull_blocks_action (boost::system::error_code const & ec, size_t size_a, nano::message_header const & header_a) { if (!ec) { auto error (false); - rai::bufferstream stream (receive_buffer->data (), sizeof (rai::uint256_union) + sizeof (rai::uint256_union) + sizeof (bulk_pull_blocks_mode) + sizeof (uint32_t)); - std::unique_ptr request (new rai::bulk_pull_blocks (error, stream, header_a)); + nano::bufferstream stream (receive_buffer->data (), sizeof (nano::uint256_union) + sizeof (nano::uint256_union) + sizeof (bulk_pull_blocks_mode) + sizeof (uint32_t)); + std::unique_ptr request (new nano::bulk_pull_blocks (error, stream, header_a)); if (!error) { if (node->config.logging.bulk_pull_logging ()) { BOOST_LOG (node->log) << boost::str (boost::format ("Received deprecated bulk pull blocks for %1% to %2%") % request->min_hash.to_string () % request->max_hash.to_string ()); } - add_request (std::unique_ptr (request.release ())); + add_request (std::unique_ptr (request.release ())); receive (); } } } -void rai::bootstrap_server::receive_frontier_req_action (boost::system::error_code const & ec, size_t size_a, rai::message_header const & header_a) +void nano::bootstrap_server::receive_frontier_req_action (boost::system::error_code const & ec, size_t size_a, nano::message_header const & header_a) { if (!ec) { auto error (false); - rai::bufferstream stream (receive_buffer->data (), sizeof (rai::uint256_union) + sizeof (uint32_t) + sizeof (uint32_t)); - std::unique_ptr request (new rai::frontier_req (error, stream, header_a)); + nano::bufferstream stream (receive_buffer->data (), sizeof (nano::uint256_union) + sizeof (uint32_t) + sizeof (uint32_t)); + std::unique_ptr request (new nano::frontier_req (error, stream, header_a)); if (!error) { if (node->config.logging.bulk_pull_logging ()) { BOOST_LOG (node->log) << boost::str (boost::format ("Received frontier request for %1% with age %2%") % request->start.to_string () % request->age); } - add_request (std::unique_ptr (request.release ())); + add_request (std::unique_ptr (request.release ())); receive (); } } @@ -1895,7 +1895,7 @@ void rai::bootstrap_server::receive_frontier_req_action (boost::system::error_co } } -void rai::bootstrap_server::add_request (std::unique_ptr message_a) +void nano::bootstrap_server::add_request (std::unique_ptr message_a) { std::lock_guard lock (mutex); auto start (requests.empty ()); @@ -1906,7 +1906,7 @@ void rai::bootstrap_server::add_request (std::unique_ptr message_a } } -void rai::bootstrap_server::finish_request () +void nano::bootstrap_server::finish_request () { std::lock_guard lock (mutex); requests.pop (); @@ -1918,64 +1918,64 @@ void rai::bootstrap_server::finish_request () namespace { -class request_response_visitor : public rai::message_visitor +class request_response_visitor : public nano::message_visitor { public: - request_response_visitor (std::shared_ptr connection_a) : + request_response_visitor (std::shared_ptr connection_a) : connection (connection_a) { } virtual ~request_response_visitor () = default; - void keepalive (rai::keepalive const &) override + void keepalive (nano::keepalive const &) override { assert (false); } - void publish (rai::publish const &) override + void publish (nano::publish const &) override { assert (false); } - void confirm_req (rai::confirm_req const &) override + void confirm_req (nano::confirm_req const &) override { assert (false); } - void confirm_ack (rai::confirm_ack const &) override + void confirm_ack (nano::confirm_ack const &) override { assert (false); } - void bulk_pull (rai::bulk_pull const &) override + void bulk_pull (nano::bulk_pull const &) override { - auto response (std::make_shared (connection, std::unique_ptr (static_cast (connection->requests.front ().release ())))); + auto response (std::make_shared (connection, std::unique_ptr (static_cast (connection->requests.front ().release ())))); response->send_next (); } - void bulk_pull_account (rai::bulk_pull_account const &) override + void bulk_pull_account (nano::bulk_pull_account const &) override { - auto response (std::make_shared (connection, std::unique_ptr (static_cast (connection->requests.front ().release ())))); + auto response (std::make_shared (connection, std::unique_ptr (static_cast (connection->requests.front ().release ())))); response->send_frontier (); } - void bulk_pull_blocks (rai::bulk_pull_blocks const &) override + void bulk_pull_blocks (nano::bulk_pull_blocks const &) override { - auto response (std::make_shared (connection, std::unique_ptr (static_cast (connection->requests.front ().release ())))); + auto response (std::make_shared (connection, std::unique_ptr (static_cast (connection->requests.front ().release ())))); response->send_next (); } - void bulk_push (rai::bulk_push const &) override + void bulk_push (nano::bulk_push const &) override { - auto response (std::make_shared (connection)); + auto response (std::make_shared (connection)); response->receive (); } - void frontier_req (rai::frontier_req const &) override + void frontier_req (nano::frontier_req const &) override { - auto response (std::make_shared (connection, std::unique_ptr (static_cast (connection->requests.front ().release ())))); + auto response (std::make_shared (connection, std::unique_ptr (static_cast (connection->requests.front ().release ())))); response->send_next (); } - void node_id_handshake (rai::node_id_handshake const &) override + void node_id_handshake (nano::node_id_handshake const &) override { assert (false); } - std::shared_ptr connection; + std::shared_ptr connection; }; } -void rai::bootstrap_server::run_next () +void nano::bootstrap_server::run_next () { assert (!requests.empty ()); request_response_visitor visitor (shared_from_this ()); @@ -1997,7 +1997,7 @@ void rai::bootstrap_server::run_next () * range will be exclusive of the frontier for that account with * a range of (frontier, end) */ -void rai::bulk_pull_server::set_current_end () +void nano::bulk_pull_server::set_current_end () { include_start = false; assert (request != nullptr); @@ -2023,7 +2023,7 @@ void rai::bulk_pull_server::set_current_end () } else { - rai::account_info info; + nano::account_info info; auto no_address (connection->node->store.account_get (transaction, request->start, info)); if (no_address) { @@ -2062,15 +2062,15 @@ void rai::bulk_pull_server::set_current_end () } } -void rai::bulk_pull_server::send_next () +void nano::bulk_pull_server::send_next () { auto block (get_next ()); if (block != nullptr) { { send_buffer->clear (); - rai::vectorstream stream (*send_buffer); - rai::serialize_block (stream, *block); + nano::vectorstream stream (*send_buffer); + nano::serialize_block (stream, *block); } auto this_l (shared_from_this ()); if (connection->node->config.logging.bulk_pull_logging ()) @@ -2087,9 +2087,9 @@ void rai::bulk_pull_server::send_next () } } -std::shared_ptr rai::bulk_pull_server::get_next () +std::shared_ptr nano::bulk_pull_server::get_next () { - std::shared_ptr result; + std::shared_ptr result; bool send_current = false, set_current_to_end = false; /* @@ -2159,7 +2159,7 @@ std::shared_ptr rai::bulk_pull_server::get_next () return result; } -void rai::bulk_pull_server::sent_action (boost::system::error_code const & ec, size_t size_a) +void nano::bulk_pull_server::sent_action (boost::system::error_code const & ec, size_t size_a) { if (!ec) { @@ -2174,10 +2174,10 @@ void rai::bulk_pull_server::sent_action (boost::system::error_code const & ec, s } } -void rai::bulk_pull_server::send_finished () +void nano::bulk_pull_server::send_finished () { send_buffer->clear (); - send_buffer->push_back (static_cast (rai::block_type::not_a_block)); + send_buffer->push_back (static_cast (nano::block_type::not_a_block)); auto this_l (shared_from_this ()); if (connection->node->config.logging.bulk_pull_logging ()) { @@ -2188,7 +2188,7 @@ void rai::bulk_pull_server::send_finished () }); } -void rai::bulk_pull_server::no_block_sent (boost::system::error_code const & ec, size_t size_a) +void nano::bulk_pull_server::no_block_sent (boost::system::error_code const & ec, size_t size_a) { if (!ec) { @@ -2204,7 +2204,7 @@ void rai::bulk_pull_server::no_block_sent (boost::system::error_code const & ec, } } -rai::bulk_pull_server::bulk_pull_server (std::shared_ptr const & connection_a, std::unique_ptr request_a) : +nano::bulk_pull_server::bulk_pull_server (std::shared_ptr const & connection_a, std::unique_ptr request_a) : connection (connection_a), request (std::move (request_a)), send_buffer (std::make_shared> ()) @@ -2215,7 +2215,7 @@ send_buffer (std::make_shared> ()) /** * Bulk pull blocks related to an account */ -void rai::bulk_pull_account_server::set_params () +void nano::bulk_pull_account_server::set_params () { assert (request != nullptr); @@ -2225,11 +2225,11 @@ void rai::bulk_pull_account_server::set_params () invalid_request = false; pending_include_address = false; pending_address_only = false; - if (request->flags == rai::bulk_pull_account_flags::pending_address_only) + if (request->flags == nano::bulk_pull_account_flags::pending_address_only) { pending_address_only = true; } - else if (request->flags == rai::bulk_pull_account_flags::pending_hash_amount_and_address) + else if (request->flags == nano::bulk_pull_account_flags::pending_hash_amount_and_address) { /** ** This is the same as "pending_hash_and_amount" but with the @@ -2237,7 +2237,7 @@ void rai::bulk_pull_account_server::set_params () **/ pending_include_address = true; } - else if (request->flags == rai::bulk_pull_account_flags::pending_hash_and_amount) + else if (request->flags == nano::bulk_pull_account_flags::pending_hash_and_amount) { /** The defaults are set above **/ } @@ -2260,7 +2260,7 @@ void rai::bulk_pull_account_server::set_params () current_key.hash = 0; } -void rai::bulk_pull_account_server::send_frontier () +void nano::bulk_pull_account_server::send_frontier () { /* * This function is really the entry point into this class, @@ -2287,14 +2287,14 @@ void rai::bulk_pull_account_server::send_frontier () **/ auto account_frontier_hash (connection->node->ledger.latest (stream_transaction, request->account)); auto account_frontier_balance_int (connection->node->ledger.account_balance (stream_transaction, request->account)); - rai::uint128_union account_frontier_balance (account_frontier_balance_int); + nano::uint128_union account_frontier_balance (account_frontier_balance_int); /** ** Write the frontier block hash and balance into a buffer **/ send_buffer->clear (); { - rai::vectorstream output_stream (*send_buffer); + nano::vectorstream output_stream (*send_buffer); write (output_stream, account_frontier_hash.bytes); write (output_stream, account_frontier_balance.bytes); @@ -2309,7 +2309,7 @@ void rai::bulk_pull_account_server::send_frontier () }); } -void rai::bulk_pull_account_server::send_next_block () +void nano::bulk_pull_account_server::send_next_block () { /* * Get the next item from the queue, it is a tuple with the key (which @@ -2328,7 +2328,7 @@ void rai::bulk_pull_account_server::send_next_block () if (pending_address_only) { - rai::vectorstream output_stream (*send_buffer); + nano::vectorstream output_stream (*send_buffer); if (connection->node->config.logging.bulk_pull_logging ()) { @@ -2339,7 +2339,7 @@ void rai::bulk_pull_account_server::send_next_block () } else { - rai::vectorstream output_stream (*send_buffer); + nano::vectorstream output_stream (*send_buffer); if (connection->node->config.logging.bulk_pull_logging ()) { @@ -2377,9 +2377,9 @@ void rai::bulk_pull_account_server::send_next_block () } } -std::pair, std::unique_ptr> rai::bulk_pull_account_server::get_next () +std::pair, std::unique_ptr> nano::bulk_pull_account_server::get_next () { - std::pair, std::unique_ptr> result; + std::pair, std::unique_ptr> result; while (true) { @@ -2391,13 +2391,13 @@ std::pair, std::unique_ptr> auto stream_transaction (connection->node->store.tx_begin_read ()); auto stream (connection->node->store.pending_begin (stream_transaction, current_key)); - if (stream == rai::store_iterator (nullptr)) + if (stream == nano::store_iterator (nullptr)) { break; } - rai::pending_key key (stream->first); - rai::pending_info info (stream->second); + nano::pending_key key (stream->first); + nano::pending_info info (stream->second); /* * Get the key for the next value, to use in the next call or iteration @@ -2449,8 +2449,8 @@ std::pair, std::unique_ptr> deduplication.insert ({ info.source, true }); } - result.first = std::unique_ptr (new rai::pending_key (key)); - result.second = std::unique_ptr (new rai::pending_info (info)); + result.first = std::unique_ptr (new nano::pending_key (key)); + result.second = std::unique_ptr (new nano::pending_info (info)); break; } @@ -2458,7 +2458,7 @@ std::pair, std::unique_ptr> return result; } -void rai::bulk_pull_account_server::sent_action (boost::system::error_code const & ec, size_t size_a) +void nano::bulk_pull_account_server::sent_action (boost::system::error_code const & ec, size_t size_a) { if (!ec) { @@ -2473,7 +2473,7 @@ void rai::bulk_pull_account_server::sent_action (boost::system::error_code const } } -void rai::bulk_pull_account_server::send_finished () +void nano::bulk_pull_account_server::send_finished () { /* * The "bulk_pull_account" final sequence is a final block of all @@ -2486,9 +2486,9 @@ void rai::bulk_pull_account_server::send_finished () send_buffer->clear (); { - rai::vectorstream output_stream (*send_buffer); - rai::uint256_union account_zero (0); - rai::uint128_union balance_zero (0); + nano::vectorstream output_stream (*send_buffer); + nano::uint256_union account_zero (0); + nano::uint128_union balance_zero (0); write (output_stream, account_zero.bytes); @@ -2514,7 +2514,7 @@ void rai::bulk_pull_account_server::send_finished () }); } -void rai::bulk_pull_account_server::complete (boost::system::error_code const & ec, size_t size_a) +void nano::bulk_pull_account_server::complete (boost::system::error_code const & ec, size_t size_a) { if (!ec) { @@ -2545,7 +2545,7 @@ void rai::bulk_pull_account_server::complete (boost::system::error_code const & } } -rai::bulk_pull_account_server::bulk_pull_account_server (std::shared_ptr const & connection_a, std::unique_ptr request_a) : +nano::bulk_pull_account_server::bulk_pull_account_server (std::shared_ptr const & connection_a, std::unique_ptr request_a) : connection (connection_a), request (std::move (request_a)), send_buffer (std::make_shared> ()), @@ -2560,27 +2560,27 @@ current_key (0, 0) /** * DEPRECATED */ -void rai::bulk_pull_blocks_server::set_params () +void nano::bulk_pull_blocks_server::set_params () { assert (request != nullptr); } -void rai::bulk_pull_blocks_server::send_next () +void nano::bulk_pull_blocks_server::send_next () { send_finished (); } -void rai::bulk_pull_blocks_server::send_finished () +void nano::bulk_pull_blocks_server::send_finished () { send_buffer->clear (); - send_buffer->push_back (static_cast (rai::block_type::not_a_block)); + send_buffer->push_back (static_cast (nano::block_type::not_a_block)); auto this_l (shared_from_this ()); connection->socket->async_write (send_buffer, [this_l](boost::system::error_code const & ec, size_t size_a) { this_l->no_block_sent (ec, size_a); }); } -void rai::bulk_pull_blocks_server::no_block_sent (boost::system::error_code const & ec, size_t size_a) +void nano::bulk_pull_blocks_server::no_block_sent (boost::system::error_code const & ec, size_t size_a) { if (!ec) { @@ -2589,7 +2589,7 @@ void rai::bulk_pull_blocks_server::no_block_sent (boost::system::error_code cons } } -rai::bulk_pull_blocks_server::bulk_pull_blocks_server (std::shared_ptr const & connection_a, std::unique_ptr request_a) : +nano::bulk_pull_blocks_server::bulk_pull_blocks_server (std::shared_ptr const & connection_a, std::unique_ptr request_a) : connection (connection_a), request (std::move (request_a)), send_buffer (std::make_shared> ()) @@ -2597,14 +2597,14 @@ send_buffer (std::make_shared> ()) set_params (); } -rai::bulk_push_server::bulk_push_server (std::shared_ptr const & connection_a) : +nano::bulk_push_server::bulk_push_server (std::shared_ptr const & connection_a) : receive_buffer (std::make_shared> ()), connection (connection_a) { receive_buffer->resize (256); } -void rai::bulk_push_server::receive () +void nano::bulk_push_server::receive () { if (connection->node->bootstrap_initiator.in_progress ()) { @@ -2632,53 +2632,53 @@ void rai::bulk_push_server::receive () } } -void rai::bulk_push_server::received_type () +void nano::bulk_push_server::received_type () { auto this_l (shared_from_this ()); - rai::block_type type (static_cast (receive_buffer->data ()[0])); + nano::block_type type (static_cast (receive_buffer->data ()[0])); switch (type) { - case rai::block_type::send: + case nano::block_type::send: { - connection->node->stats.inc (rai::stat::type::bootstrap, rai::stat::detail::send, rai::stat::dir::in); - connection->socket->async_read (receive_buffer, rai::send_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { + connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::send, nano::stat::dir::in); + connection->socket->async_read (receive_buffer, nano::send_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { this_l->received_block (ec, size_a, type); }); break; } - case rai::block_type::receive: + case nano::block_type::receive: { - connection->node->stats.inc (rai::stat::type::bootstrap, rai::stat::detail::receive, rai::stat::dir::in); - connection->socket->async_read (receive_buffer, rai::receive_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { + connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::receive, nano::stat::dir::in); + connection->socket->async_read (receive_buffer, nano::receive_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { this_l->received_block (ec, size_a, type); }); break; } - case rai::block_type::open: + case nano::block_type::open: { - connection->node->stats.inc (rai::stat::type::bootstrap, rai::stat::detail::open, rai::stat::dir::in); - connection->socket->async_read (receive_buffer, rai::open_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { + connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::open, nano::stat::dir::in); + connection->socket->async_read (receive_buffer, nano::open_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { this_l->received_block (ec, size_a, type); }); break; } - case rai::block_type::change: + case nano::block_type::change: { - connection->node->stats.inc (rai::stat::type::bootstrap, rai::stat::detail::change, rai::stat::dir::in); - connection->socket->async_read (receive_buffer, rai::change_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { + connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::change, nano::stat::dir::in); + connection->socket->async_read (receive_buffer, nano::change_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { this_l->received_block (ec, size_a, type); }); break; } - case rai::block_type::state: + case nano::block_type::state: { - connection->node->stats.inc (rai::stat::type::bootstrap, rai::stat::detail::state_block, rai::stat::dir::in); - connection->socket->async_read (receive_buffer, rai::state_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { + connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::state_block, nano::stat::dir::in); + connection->socket->async_read (receive_buffer, nano::state_block::size, [this_l, type](boost::system::error_code const & ec, size_t size_a) { this_l->received_block (ec, size_a, type); }); break; } - case rai::block_type::not_a_block: + case nano::block_type::not_a_block: { connection->finish_request (); break; @@ -2694,13 +2694,13 @@ void rai::bulk_push_server::received_type () } } -void rai::bulk_push_server::received_block (boost::system::error_code const & ec, size_t size_a, rai::block_type type_a) +void nano::bulk_push_server::received_block (boost::system::error_code const & ec, size_t size_a, nano::block_type type_a) { if (!ec) { - rai::bufferstream stream (receive_buffer->data (), size_a); - auto block (rai::deserialize_block (stream, type_a)); - if (block != nullptr && !rai::work_validate (*block)) + nano::bufferstream stream (receive_buffer->data (), size_a); + auto block (nano::deserialize_block (stream, type_a)); + if (block != nullptr && !nano::work_validate (*block)) { connection->node->process_active (std::move (block)); receive (); @@ -2715,7 +2715,7 @@ void rai::bulk_push_server::received_block (boost::system::error_code const & ec } } -rai::frontier_req_server::frontier_req_server (std::shared_ptr const & connection_a, std::unique_ptr request_a) : +nano::frontier_req_server::frontier_req_server (std::shared_ptr const & connection_a, std::unique_ptr request_a) : connection (connection_a), current (request_a->start.number () - 1), frontier (0), @@ -2726,13 +2726,13 @@ count (0) next (); } -void rai::frontier_req_server::send_next () +void nano::frontier_req_server::send_next () { if (!current.is_zero () && count <= request->count) { { send_buffer->clear (); - rai::vectorstream stream (*send_buffer); + nano::vectorstream stream (*send_buffer); write (stream, current.bytes); write (stream, frontier.bytes); } @@ -2752,12 +2752,12 @@ void rai::frontier_req_server::send_next () } } -void rai::frontier_req_server::send_finished () +void nano::frontier_req_server::send_finished () { { send_buffer->clear (); - rai::vectorstream stream (*send_buffer); - rai::uint256_union zero (0); + nano::vectorstream stream (*send_buffer); + nano::uint256_union zero (0); write (stream, zero.bytes); write (stream, zero.bytes); } @@ -2771,7 +2771,7 @@ void rai::frontier_req_server::send_finished () }); } -void rai::frontier_req_server::no_block_sent (boost::system::error_code const & ec, size_t size_a) +void nano::frontier_req_server::no_block_sent (boost::system::error_code const & ec, size_t size_a) { if (!ec) { @@ -2786,7 +2786,7 @@ void rai::frontier_req_server::no_block_sent (boost::system::error_code const & } } -void rai::frontier_req_server::sent_action (boost::system::error_code const & ec, size_t size_a) +void nano::frontier_req_server::sent_action (boost::system::error_code const & ec, size_t size_a) { if (!ec) { @@ -2802,28 +2802,28 @@ void rai::frontier_req_server::sent_action (boost::system::error_code const & ec } } -void rai::frontier_req_server::next () +void nano::frontier_req_server::next () { // Filling accounts deque to prevent often read transactions if (accounts.empty ()) { - auto now (rai::seconds_since_epoch ()); + auto now (nano::seconds_since_epoch ()); bool skip_old (request->age != std::numeric_limitsage)>::max ()); size_t max_size (128); auto transaction (connection->node->store.tx_begin_read ()); for (auto i (connection->node->store.latest_begin (transaction, current.number () + 1)), n (connection->node->store.latest_end ()); i != n && accounts.size () != max_size; ++i) { - rai::account_info info (i->second); + nano::account_info info (i->second); if (!skip_old || (now - info.modified) <= request->age) { - accounts.push_back (std::make_pair (rai::account (i->first), info.head)); + accounts.push_back (std::make_pair (nano::account (i->first), info.head)); } } /* If loop breaks before max_size, then latest_end () is reached Add empty record to finish frontier_req_server */ if (accounts.size () != max_size) { - accounts.push_back (std::make_pair (rai::account (0), rai::block_hash (0))); + accounts.push_back (std::make_pair (nano::account (0), nano::block_hash (0))); } } // Retrieving accounts from deque diff --git a/nano/node/bootstrap.hpp b/nano/node/bootstrap.hpp new file mode 100644 index 00000000..2c74a623 --- /dev/null +++ b/nano/node/bootstrap.hpp @@ -0,0 +1,341 @@ +#pragma once + +#include +#include +#include + +#include +#include +#include +#include +#include + +#include +#include + +namespace nano +{ +class bootstrap_attempt; +class bootstrap_client; +class node; +enum class sync_result +{ + success, + error, + fork +}; +class socket : public std::enable_shared_from_this +{ +public: + socket (std::shared_ptr); + void async_connect (nano::tcp_endpoint const &, std::function); + void async_read (std::shared_ptr>, size_t, std::function); + void async_write (std::shared_ptr>, std::function); + void start (std::chrono::steady_clock::time_point = std::chrono::steady_clock::now () + std::chrono::seconds (5)); + void stop (); + void close (); + void checkup (); + nano::tcp_endpoint remote_endpoint (); + boost::asio::ip::tcp::socket socket_m; + +private: + std::atomic cutoff; + std::shared_ptr node; +}; + +/** + * The length of every message header, parsed by nano::message::read_header () + * The 2 here represents the size of a std::bitset<16>, which is 2 chars long normally + */ +static const int bootstrap_message_header_size = sizeof (nano::message_header::magic_number) + sizeof (uint8_t) + sizeof (uint8_t) + sizeof (uint8_t) + sizeof (nano::message_type) + 2; + +class bootstrap_client; +class pull_info +{ +public: + typedef nano::bulk_pull::count_t count_t; + pull_info (); + pull_info (nano::account const &, nano::block_hash const &, nano::block_hash const &, count_t = 0); + nano::account account; + nano::block_hash head; + nano::block_hash end; + count_t count; + unsigned attempts; +}; +class frontier_req_client; +class bulk_push_client; +class bootstrap_attempt : public std::enable_shared_from_this +{ +public: + bootstrap_attempt (std::shared_ptr node_a); + ~bootstrap_attempt (); + void run (); + std::shared_ptr connection (std::unique_lock &); + bool consume_future (std::future &); + void populate_connections (); + bool request_frontier (std::unique_lock &); + void request_pull (std::unique_lock &); + void request_push (std::unique_lock &); + void add_connection (nano::endpoint const &); + void pool_connection (std::shared_ptr); + void stop (); + void requeue_pull (nano::pull_info const &); + void add_pull (nano::pull_info const &); + bool still_pulling (); + unsigned target_connections (size_t pulls_remaining); + bool should_log (); + void add_bulk_push_target (nano::block_hash const &, nano::block_hash const &); + bool process_block (std::shared_ptr, uint64_t, bool); + void lazy_run (); + void lazy_start (nano::block_hash const &); + void lazy_add (nano::block_hash const &); + bool lazy_finished (); + void lazy_pull_flush (); + std::chrono::steady_clock::time_point next_log; + std::deque> clients; + std::weak_ptr connection_frontier_request; + std::weak_ptr frontiers; + std::weak_ptr push; + std::deque pulls; + std::deque> idle; + std::atomic connections; + std::atomic pulling; + std::shared_ptr node; + std::atomic account_count; + std::atomic total_blocks; + std::vector> bulk_push_targets; + bool stopped; + bool lazy_mode; + std::mutex mutex; + std::condition_variable condition; + // Lazy bootstrap + std::unordered_set lazy_blocks; + std::unordered_map> lazy_state_unknown; + std::unordered_map lazy_balances; + std::unordered_set lazy_keys; + std::deque lazy_pulls; + std::atomic lazy_stopped; + uint64_t lazy_max_pull_blocks = (nano::nano_network == nano::nano_networks::nano_test_network) ? 2 : 512; + uint64_t lazy_max_stopped = 256; + std::mutex lazy_mutex; +}; +class frontier_req_client : public std::enable_shared_from_this +{ +public: + frontier_req_client (std::shared_ptr); + ~frontier_req_client (); + void run (); + void receive_frontier (); + void received_frontier (boost::system::error_code const &, size_t); + void request_account (nano::account const &, nano::block_hash const &); + void unsynced (nano::block_hash const &, nano::block_hash const &); + void next (nano::transaction const &); + void insert_pull (nano::pull_info const &); + std::shared_ptr connection; + nano::account current; + nano::block_hash frontier; + unsigned count; + nano::account landing; + nano::account faucet; + std::chrono::steady_clock::time_point start_time; + std::promise promise; + /** A very rough estimate of the cost of `bulk_push`ing missing blocks */ + uint64_t bulk_push_cost; + std::deque> accounts; +}; +class bulk_pull_client : public std::enable_shared_from_this +{ +public: + bulk_pull_client (std::shared_ptr, nano::pull_info const &); + ~bulk_pull_client (); + void request (); + void receive_block (); + void received_type (); + void received_block (boost::system::error_code const &, size_t, nano::block_type); + nano::block_hash first (); + std::shared_ptr connection; + nano::block_hash expected; + nano::pull_info pull; + uint64_t total_blocks; +}; +class bootstrap_client : public std::enable_shared_from_this +{ +public: + bootstrap_client (std::shared_ptr, std::shared_ptr, nano::tcp_endpoint const &); + ~bootstrap_client (); + void run (); + std::shared_ptr shared (); + void stop (bool force); + double block_rate () const; + double elapsed_seconds () const; + std::shared_ptr node; + std::shared_ptr attempt; + std::shared_ptr socket; + std::shared_ptr> receive_buffer; + nano::tcp_endpoint endpoint; + std::chrono::steady_clock::time_point start_time; + std::atomic block_count; + std::atomic pending_stop; + std::atomic hard_stop; +}; +class bulk_push_client : public std::enable_shared_from_this +{ +public: + bulk_push_client (std::shared_ptr const &); + ~bulk_push_client (); + void start (); + void push (nano::transaction const &); + void push_block (nano::block const &); + void send_finished (); + std::shared_ptr connection; + std::promise promise; + std::pair current_target; +}; +class bootstrap_initiator +{ +public: + bootstrap_initiator (nano::node &); + ~bootstrap_initiator (); + void bootstrap (nano::endpoint const &, bool add_to_peers = true); + void bootstrap (); + void bootstrap_lazy (nano::block_hash const &, bool = false); + void run_bootstrap (); + void notify_listeners (bool); + void add_observer (std::function const &); + bool in_progress (); + std::shared_ptr current_attempt (); + void stop (); + +private: + nano::node & node; + std::shared_ptr attempt; + bool stopped; + std::mutex mutex; + std::condition_variable condition; + std::vector> observers; + boost::thread thread; +}; +class bootstrap_server; +class bootstrap_listener +{ +public: + bootstrap_listener (boost::asio::io_context &, uint16_t, nano::node &); + void start (); + void stop (); + void accept_connection (); + void accept_action (boost::system::error_code const &, std::shared_ptr); + std::mutex mutex; + std::unordered_map> connections; + nano::tcp_endpoint endpoint (); + boost::asio::ip::tcp::acceptor acceptor; + nano::tcp_endpoint local; + boost::asio::io_context & io_ctx; + nano::node & node; + bool on; +}; +class message; +class bootstrap_server : public std::enable_shared_from_this +{ +public: + bootstrap_server (std::shared_ptr, std::shared_ptr); + ~bootstrap_server (); + void receive (); + void receive_header_action (boost::system::error_code const &, size_t); + void receive_bulk_pull_action (boost::system::error_code const &, size_t, nano::message_header const &); + void receive_bulk_pull_account_action (boost::system::error_code const &, size_t, nano::message_header const &); + void receive_bulk_pull_blocks_action (boost::system::error_code const &, size_t, nano::message_header const &); + void receive_frontier_req_action (boost::system::error_code const &, size_t, nano::message_header const &); + void receive_bulk_push_action (); + void add_request (std::unique_ptr); + void finish_request (); + void run_next (); + std::shared_ptr> receive_buffer; + std::shared_ptr socket; + std::shared_ptr node; + std::mutex mutex; + std::queue> requests; +}; +class bulk_pull; +class bulk_pull_server : public std::enable_shared_from_this +{ +public: + bulk_pull_server (std::shared_ptr const &, std::unique_ptr); + void set_current_end (); + std::shared_ptr get_next (); + void send_next (); + void sent_action (boost::system::error_code const &, size_t); + void send_finished (); + void no_block_sent (boost::system::error_code const &, size_t); + std::shared_ptr connection; + std::unique_ptr request; + std::shared_ptr> send_buffer; + nano::block_hash current; + bool include_start; + nano::bulk_pull::count_t max_count; + nano::bulk_pull::count_t sent_count; +}; +class bulk_pull_account; +class bulk_pull_account_server : public std::enable_shared_from_this +{ +public: + bulk_pull_account_server (std::shared_ptr const &, std::unique_ptr); + void set_params (); + std::pair, std::unique_ptr> get_next (); + void send_frontier (); + void send_next_block (); + void sent_action (boost::system::error_code const &, size_t); + void send_finished (); + void complete (boost::system::error_code const &, size_t); + std::shared_ptr connection; + std::unique_ptr request; + std::shared_ptr> send_buffer; + std::unordered_map deduplication; + nano::pending_key current_key; + bool pending_address_only; + bool pending_include_address; + bool invalid_request; +}; +class bulk_pull_blocks; +class bulk_pull_blocks_server : public std::enable_shared_from_this +{ +public: + bulk_pull_blocks_server (std::shared_ptr const &, std::unique_ptr); + void set_params (); + std::shared_ptr get_next (); + void send_next (); + void send_finished (); + void no_block_sent (boost::system::error_code const &, size_t); + std::shared_ptr connection; + std::unique_ptr request; + std::shared_ptr> send_buffer; +}; +class bulk_push_server : public std::enable_shared_from_this +{ +public: + bulk_push_server (std::shared_ptr const &); + void receive (); + void receive_block (); + void received_type (); + void received_block (boost::system::error_code const &, size_t, nano::block_type); + std::shared_ptr> receive_buffer; + std::shared_ptr connection; +}; +class frontier_req; +class frontier_req_server : public std::enable_shared_from_this +{ +public: + frontier_req_server (std::shared_ptr const &, std::unique_ptr); + void send_next (); + void sent_action (boost::system::error_code const &, size_t); + void send_finished (); + void no_block_sent (boost::system::error_code const &, size_t); + void next (); + std::shared_ptr connection; + nano::account current; + nano::block_hash frontier; + std::unique_ptr request; + std::shared_ptr> send_buffer; + size_t count; + std::deque> accounts; +}; +} diff --git a/rai/node/cli.cpp b/nano/node/cli.cpp similarity index 82% rename from rai/node/cli.cpp rename to nano/node/cli.cpp index 307ef62d..db0f532d 100644 --- a/rai/node/cli.cpp +++ b/nano/node/cli.cpp @@ -1,26 +1,26 @@ -#include -#include -#include -#include +#include +#include +#include +#include -std::string rai::error_cli_messages::message (int ev) const +std::string nano::error_cli_messages::message (int ev) const { - switch (static_cast (ev)) + switch (static_cast (ev)) { - case rai::error_cli::generic: + case nano::error_cli::generic: return "Unknown error"; - case rai::error_cli::parse_error: + case nano::error_cli::parse_error: return "Coud not parse command line"; - case rai::error_cli::invalid_arguments: + case nano::error_cli::invalid_arguments: return "Invalid arguments"; - case rai::error_cli::unknown_command: + case nano::error_cli::unknown_command: return "Unknown command"; } return "Invalid error code"; } -void rai::add_node_options (boost::program_options::options_description & description_a) +void nano::add_node_options (boost::program_options::options_description & description_a) { // clang-format off description_a.add_options () @@ -56,16 +56,16 @@ void rai::add_node_options (boost::program_options::options_description & descri // clang-format on } -std::error_code rai::handle_node_options (boost::program_options::variables_map & vm) +std::error_code nano::handle_node_options (boost::program_options::variables_map & vm) { std::error_code ec; - boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : rai::working_path (); + boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : nano::working_path (); if (vm.count ("account_create")) { if (vm.count ("wallet") == 1) { - rai::uint256_union wallet_id; + nano::uint256_union wallet_id; if (!wallet_id.decode_hex (vm["wallet"].as ())) { std::string password; @@ -86,53 +86,53 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map else { std::cerr << "Invalid password\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Wallet doesn't exist\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Invalid wallet id\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "wallet_add command requires one option and one option and optionally one option\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else if (vm.count ("account_get") > 0) { if (vm.count ("key") == 1) { - rai::uint256_union pub; + nano::uint256_union pub; pub.decode_hex (vm["key"].as ()); std::cout << "Account: " << pub.to_account () << std::endl; } else { std::cerr << "account comand requires one option\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else if (vm.count ("account_key") > 0) { if (vm.count ("account") == 1) { - rai::uint256_union account; + nano::uint256_union account; account.decode_account (vm["account"].as ()); std::cout << "Hex: " << account.to_string () << std::endl; } else { std::cerr << "account_key command requires one option\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else if (vm.count ("vacuum") > 0) @@ -196,7 +196,7 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map { try { - boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : rai::working_path (); + boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : nano::working_path (); auto source_path = data_path / "data.ldb"; auto snapshot_path = data_path / "snapshot.ldb"; @@ -244,7 +244,7 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map } else if (vm.count ("unchecked_clear")) { - boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : rai::working_path (); + boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : nano::working_path (); inactive_node node (data_path); auto transaction (node.node->store.tx_begin_write ()); node.node->store.unchecked_clear (transaction); @@ -252,7 +252,7 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map } else if (vm.count ("delete_node_id")) { - boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : rai::working_path (); + boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : nano::working_path (); inactive_node node (data_path); auto transaction (node.node->store.tx_begin_write ()); node.node->store.delete_node_id (transaction); @@ -260,7 +260,7 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map } else if (vm.count ("clear_send_ids")) { - boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : rai::working_path (); + boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : nano::working_path (); inactive_node node (data_path); auto transaction (node.node->store.tx_begin_write ()); node.node->wallets.clear_send_ids (transaction); @@ -270,18 +270,18 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map { inactive_node node (data_path); std::cout << "Testing hash function" << std::endl; - rai::raw_key key; + nano::raw_key key; key.data.clear (); - rai::send_block send (0, 0, 0, key, 0, 0); + nano::send_block send (0, 0, 0, key, 0, 0); std::cout << "Testing key derivation function" << std::endl; - rai::raw_key junk1; + nano::raw_key junk1; junk1.data.clear (); - rai::uint256_union junk2 (0); - rai::kdf kdf; + nano::uint256_union junk2 (0); + nano::kdf kdf; kdf.phs (junk1, "", junk2); std::cout << "Dumping OpenCL information" << std::endl; bool error (false); - rai::opencl_environment environment (error); + nano::opencl_environment environment (error); if (!error) { environment.dump (std::cout); @@ -296,7 +296,7 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map } else if (vm.count ("key_create")) { - rai::keypair pair; + nano::keypair pair; std::cout << "Private: " << pair.prv.data.to_string () << std::endl << "Public: " << pair.pub.to_string () << std::endl << "Account: " << pair.pub.to_account () << std::endl; @@ -305,9 +305,9 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map { if (vm.count ("key") == 1) { - rai::uint256_union prv; + nano::uint256_union prv; prv.decode_hex (vm["key"].as ()); - rai::uint256_union pub (rai::pub_key (prv)); + nano::uint256_union pub (nano::pub_key (prv)); std::cout << "Private: " << prv.to_string () << std::endl << "Public: " << pub.to_string () << std::endl << "Account: " << pub.to_account () << std::endl; @@ -315,14 +315,14 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map else { std::cerr << "key_expand command requires one option\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else if (vm.count ("wallet_add_adhoc")) { if (vm.count ("wallet") == 1 && vm.count ("key") == 1) { - rai::uint256_union wallet_id; + nano::uint256_union wallet_id; if (!wallet_id.decode_hex (vm["wallet"].as ())) { std::string password; @@ -337,7 +337,7 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map auto transaction (wallet->wallets.tx_begin_write ()); if (!wallet->enter_password (transaction, password)) { - rai::raw_key key; + nano::raw_key key; if (!key.data.decode_hex (vm["key"].as ())) { wallet->store.insert_adhoc (transaction, key); @@ -345,38 +345,38 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map else { std::cerr << "Invalid key\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Invalid password\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Wallet doesn't exist\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Invalid wallet id\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "wallet_add command requires one option and one option and optionally one option\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else if (vm.count ("wallet_change_seed")) { if (vm.count ("wallet") == 1 && vm.count ("key") == 1) { - rai::uint256_union wallet_id; + nano::uint256_union wallet_id; if (!wallet_id.decode_hex (vm["wallet"].as ())) { std::string password; @@ -391,7 +391,7 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map auto transaction (wallet->wallets.tx_begin_write ()); if (!wallet->enter_password (transaction, password)) { - rai::raw_key key; + nano::raw_key key; if (!key.data.decode_hex (vm["key"].as ())) { wallet->change_seed (transaction, key); @@ -399,37 +399,37 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map else { std::cerr << "Invalid key\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Invalid password\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Wallet doesn't exist\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Invalid wallet id\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "wallet_add command requires one option and one option and optionally one option\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else if (vm.count ("wallet_create")) { inactive_node node (data_path); - rai::keypair key; + nano::keypair key; std::cout << key.pub.to_string () << std::endl; auto wallet (node.node->wallets.create (key.pub)); } @@ -442,7 +442,7 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map { password = vm["password"].as (); } - rai::uint256_union wallet_id; + nano::uint256_union wallet_id; if (!wallet_id.decode_hex (vm["wallet"].as ())) { inactive_node node (data_path); @@ -452,17 +452,17 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map auto transaction (existing->second->wallets.tx_begin_write ()); if (!existing->second->enter_password (transaction, password)) { - rai::raw_key seed; + nano::raw_key seed; existing->second->store.seed (seed, transaction); std::cout << boost::str (boost::format ("Seed: %1%\n") % seed.data.to_string ()); for (auto i (existing->second->store.begin (transaction)), m (existing->second->store.end ()); i != m; ++i) { - rai::account account (i->first); - rai::raw_key key; + nano::account account (i->first); + nano::raw_key key; auto error (existing->second->store.fetch (transaction, account, key)); assert (!error); std::cout << boost::str (boost::format ("Pub: %1% Prv: %2%\n") % account.to_account () % key.data.to_string ()); - if (rai::pub_key (key.data) != account) + if (nano::pub_key (key.data) != account) { std::cerr << boost::str (boost::format ("Invalid private key %1%\n") % key.data.to_string ()); } @@ -471,32 +471,32 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map else { std::cerr << "Invalid password\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Wallet doesn't exist\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Invalid wallet id\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "wallet_decrypt_unsafe requires one option\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else if (vm.count ("wallet_destroy")) { if (vm.count ("wallet") == 1) { - rai::uint256_union wallet_id; + nano::uint256_union wallet_id; if (!wallet_id.decode_hex (vm["wallet"].as ())) { inactive_node node (data_path); @@ -507,19 +507,19 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map else { std::cerr << "Wallet doesn't exist\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Invalid wallet id\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "wallet_destroy requires one option\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else if (vm.count ("wallet_import")) @@ -545,7 +545,7 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map } if (vm.count ("wallet") == 1) { - rai::uint256_union wallet_id; + nano::uint256_union wallet_id; if (!wallet_id.decode_hex (vm["wallet"].as ())) { inactive_node node (data_path); @@ -555,7 +555,7 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map if (existing->second->import (contents.str (), password)) { std::cerr << "Unable to import wallet\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else @@ -563,7 +563,7 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map if (!forced) { std::cerr << "Wallet doesn't exist\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } else { @@ -572,7 +572,7 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map if (existing->second->import (contents.str (), password)) { std::cerr << "Unable to import wallet\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } } @@ -580,25 +580,25 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map else { std::cerr << "Invalid wallet id\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "wallet_import requires one option\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Unable to open \n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "wallet_import requires one option\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else if (vm.count ("wallet_list")) @@ -610,7 +610,7 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map auto transaction (i->second->wallets.tx_begin_read ()); for (auto j (i->second->store.begin (transaction)), m (i->second->store.end ()); j != m; ++j) { - std::cout << rai::uint256_union (j->first).to_account () << '\n'; + std::cout << nano::uint256_union (j->first).to_account () << '\n'; } } } @@ -619,13 +619,13 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map if (vm.count ("wallet") == 1 && vm.count ("account") == 1) { inactive_node node (data_path); - rai::uint256_union wallet_id; + nano::uint256_union wallet_id; if (!wallet_id.decode_hex (vm["wallet"].as ())) { auto wallet (node.node->wallets.items.find (wallet_id)); if (wallet != node.node->wallets.items.end ()) { - rai::account account_id; + nano::account account_id; if (!account_id.decode_account (vm["account"].as ())) { auto transaction (wallet->second->wallets.tx_begin_write ()); @@ -637,38 +637,38 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map else { std::cerr << "Account not found in wallet\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Invalid account id\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Wallet not found\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Invalid wallet id\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "wallet_remove command requires one and one option\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else if (vm.count ("wallet_representative_get")) { if (vm.count ("wallet") == 1) { - rai::uint256_union wallet_id; + nano::uint256_union wallet_id; if (!wallet_id.decode_hex (vm["wallet"].as ())) { inactive_node node (data_path); @@ -682,19 +682,19 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map else { std::cerr << "Wallet not found\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Invalid wallet id\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "wallet_representative_get requires one option\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else if (vm.count ("wallet_representative_set")) @@ -703,10 +703,10 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map { if (vm.count ("account") == 1) { - rai::uint256_union wallet_id; + nano::uint256_union wallet_id; if (!wallet_id.decode_hex (vm["wallet"].as ())) { - rai::account account; + nano::account account; if (!account.decode_account (vm["account"].as ())) { inactive_node node (data_path); @@ -719,31 +719,31 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map else { std::cerr << "Wallet not found\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Invalid account\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "Invalid wallet id\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "wallet_representative_set requires one option\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else { std::cerr << "wallet_representative_set requires one option\n"; - ec = rai::error_cli::invalid_arguments; + ec = nano::error_cli::invalid_arguments; } } else if (vm.count ("vote_dump") == 1) @@ -758,7 +758,7 @@ std::error_code rai::handle_node_options (boost::program_options::variables_map } else { - ec = rai::error_cli::unknown_command; + ec = nano::error_cli::unknown_command; } return ec; diff --git a/rai/node/cli.hpp b/nano/node/cli.hpp similarity index 80% rename from rai/node/cli.hpp rename to nano/node/cli.hpp index f9a99bcf..6e2b0aa0 100644 --- a/rai/node/cli.hpp +++ b/nano/node/cli.hpp @@ -1,9 +1,9 @@ #pragma once #include -#include +#include -namespace rai +namespace nano { /** Command line related error codes */ enum class error_cli @@ -18,4 +18,4 @@ void add_node_options (boost::program_options::options_description &); std::error_code handle_node_options (boost::program_options::variables_map &); } -REGISTER_ERROR_CODES (rai, error_cli) +REGISTER_ERROR_CODES (nano, error_cli) diff --git a/nano/node/common.cpp b/nano/node/common.cpp new file mode 100644 index 00000000..9a589844 --- /dev/null +++ b/nano/node/common.cpp @@ -0,0 +1,974 @@ + +#include + +#include +#include + +#include + +std::array constexpr nano::message_header::magic_number; +std::bitset<16> constexpr nano::message_header::block_type_mask; + +nano::message_header::message_header (nano::message_type type_a) : +version_max (nano::protocol_version), +version_using (nano::protocol_version), +version_min (nano::protocol_version_min), +type (type_a) +{ +} + +nano::message_header::message_header (bool & error_a, nano::stream & stream_a) +{ + if (!error_a) + { + error_a = deserialize (stream_a); + } +} + +void nano::message_header::serialize (nano::stream & stream_a) const +{ + nano::write (stream_a, nano::message_header::magic_number); + nano::write (stream_a, version_max); + nano::write (stream_a, version_using); + nano::write (stream_a, version_min); + nano::write (stream_a, type); + nano::write (stream_a, static_cast (extensions.to_ullong ())); +} + +bool nano::message_header::deserialize (nano::stream & stream_a) +{ + uint16_t extensions_l; + std::array magic_number_l; + auto result (nano::read (stream_a, magic_number_l)); + result = result || magic_number_l != magic_number; + result = result || nano::read (stream_a, version_max); + result = result || nano::read (stream_a, version_using); + result = result || nano::read (stream_a, version_min); + result = result || nano::read (stream_a, type); + result = result || nano::read (stream_a, extensions_l); + if (!result) + { + extensions = extensions_l; + } + return result; +} + +nano::message::message (nano::message_type type_a) : +header (type_a) +{ +} + +nano::message::message (nano::message_header const & header_a) : +header (header_a) +{ +} + +nano::block_type nano::message_header::block_type () const +{ + return static_cast (((extensions & block_type_mask) >> 8).to_ullong ()); +} + +void nano::message_header::block_type_set (nano::block_type type_a) +{ + extensions &= ~block_type_mask; + extensions |= std::bitset<16> (static_cast (type_a) << 8); +} + +bool nano::message_header::bulk_pull_is_count_present () const +{ + auto result (false); + if (type == nano::message_type::bulk_pull) + { + if (extensions.test (bulk_pull_count_present_flag)) + { + result = true; + } + } + + return result; +} + +// MTU - IP header - UDP header +const size_t nano::message_parser::max_safe_udp_message_size = 508; + +std::string nano::message_parser::status_string () +{ + switch (status) + { + case nano::message_parser::parse_status::success: + { + return "success"; + } + case nano::message_parser::parse_status::insufficient_work: + { + return "insufficient_work"; + } + case nano::message_parser::parse_status::invalid_header: + { + return "invalid_header"; + } + case nano::message_parser::parse_status::invalid_message_type: + { + return "invalid_message_type"; + } + case nano::message_parser::parse_status::invalid_keepalive_message: + { + return "invalid_keepalive_message"; + } + case nano::message_parser::parse_status::invalid_publish_message: + { + return "invalid_publish_message"; + } + case nano::message_parser::parse_status::invalid_confirm_req_message: + { + return "invalid_confirm_req_message"; + } + case nano::message_parser::parse_status::invalid_confirm_ack_message: + { + return "invalid_confirm_ack_message"; + } + case nano::message_parser::parse_status::invalid_node_id_handshake_message: + { + return "invalid_node_id_handshake_message"; + } + case nano::message_parser::parse_status::outdated_version: + { + return "outdated_version"; + } + case nano::message_parser::parse_status::invalid_magic: + { + return "invalid_magic"; + } + case nano::message_parser::parse_status::invalid_network: + { + return "invalid_network"; + } + } + + assert (false); + + return "[unknown parse_status]"; +} + +nano::message_parser::message_parser (nano::block_uniquer & block_uniquer_a, nano::vote_uniquer & vote_uniquer_a, nano::message_visitor & visitor_a, nano::work_pool & pool_a) : +block_uniquer (block_uniquer_a), +vote_uniquer (vote_uniquer_a), +visitor (visitor_a), +pool (pool_a), +status (parse_status::success) +{ +} + +void nano::message_parser::deserialize_buffer (uint8_t const * buffer_a, size_t size_a) +{ + status = parse_status::success; + auto error (false); + if (size_a <= max_safe_udp_message_size) + { + // Guaranteed to be deliverable + nano::bufferstream stream (buffer_a, size_a); + nano::message_header header (error, stream); + if (!error) + { + if (nano::nano_network == nano::nano_networks::nano_beta_network && header.version_using < nano::protocol_version_reasonable_min) + { + status = parse_status::outdated_version; + } + else if (!header.valid_magic ()) + { + status = parse_status::invalid_magic; + } + else if (!header.valid_network ()) + { + status = parse_status::invalid_network; + } + else + { + switch (header.type) + { + case nano::message_type::keepalive: + { + deserialize_keepalive (stream, header); + break; + } + case nano::message_type::publish: + { + deserialize_publish (stream, header); + break; + } + case nano::message_type::confirm_req: + { + deserialize_confirm_req (stream, header); + break; + } + case nano::message_type::confirm_ack: + { + deserialize_confirm_ack (stream, header); + break; + } + case nano::message_type::node_id_handshake: + { + deserialize_node_id_handshake (stream, header); + break; + } + default: + { + status = parse_status::invalid_message_type; + break; + } + } + } + } + else + { + status = parse_status::invalid_header; + } + } +} + +void nano::message_parser::deserialize_keepalive (nano::stream & stream_a, nano::message_header const & header_a) +{ + auto error (false); + nano::keepalive incoming (error, stream_a, header_a); + if (!error && at_end (stream_a)) + { + visitor.keepalive (incoming); + } + else + { + status = parse_status::invalid_keepalive_message; + } +} + +void nano::message_parser::deserialize_publish (nano::stream & stream_a, nano::message_header const & header_a) +{ + auto error (false); + nano::publish incoming (error, stream_a, header_a, &block_uniquer); + if (!error && at_end (stream_a)) + { + if (!nano::work_validate (*incoming.block)) + { + visitor.publish (incoming); + } + else + { + status = parse_status::insufficient_work; + } + } + else + { + status = parse_status::invalid_publish_message; + } +} + +void nano::message_parser::deserialize_confirm_req (nano::stream & stream_a, nano::message_header const & header_a) +{ + auto error (false); + nano::confirm_req incoming (error, stream_a, header_a, &block_uniquer); + if (!error && at_end (stream_a)) + { + if (!nano::work_validate (*incoming.block)) + { + visitor.confirm_req (incoming); + } + else + { + status = parse_status::insufficient_work; + } + } + else + { + status = parse_status::invalid_confirm_req_message; + } +} + +void nano::message_parser::deserialize_confirm_ack (nano::stream & stream_a, nano::message_header const & header_a) +{ + auto error (false); + nano::confirm_ack incoming (error, stream_a, header_a, &vote_uniquer); + if (!error && at_end (stream_a)) + { + for (auto & vote_block : incoming.vote->blocks) + { + if (!vote_block.which ()) + { + auto block (boost::get> (vote_block)); + if (nano::work_validate (*block)) + { + status = parse_status::insufficient_work; + break; + } + } + } + if (status == parse_status::success) + { + visitor.confirm_ack (incoming); + } + } + else + { + status = parse_status::invalid_confirm_ack_message; + } +} + +void nano::message_parser::deserialize_node_id_handshake (nano::stream & stream_a, nano::message_header const & header_a) +{ + bool error_l (false); + nano::node_id_handshake incoming (error_l, stream_a, header_a); + if (!error_l && at_end (stream_a)) + { + visitor.node_id_handshake (incoming); + } + else + { + status = parse_status::invalid_node_id_handshake_message; + } +} + +bool nano::message_parser::at_end (nano::stream & stream_a) +{ + uint8_t junk; + auto end (nano::read (stream_a, junk)); + return end; +} + +nano::keepalive::keepalive () : +message (nano::message_type::keepalive) +{ + nano::endpoint endpoint (boost::asio::ip::address_v6{}, 0); + for (auto i (peers.begin ()), n (peers.end ()); i != n; ++i) + { + *i = endpoint; + } +} + +nano::keepalive::keepalive (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) : +message (header_a) +{ + if (!error_a) + { + error_a = deserialize (stream_a); + } +} + +void nano::keepalive::visit (nano::message_visitor & visitor_a) const +{ + visitor_a.keepalive (*this); +} + +void nano::keepalive::serialize (nano::stream & stream_a) const +{ + header.serialize (stream_a); + for (auto i (peers.begin ()), j (peers.end ()); i != j; ++i) + { + assert (i->address ().is_v6 ()); + auto bytes (i->address ().to_v6 ().to_bytes ()); + write (stream_a, bytes); + write (stream_a, i->port ()); + } +} + +bool nano::keepalive::deserialize (nano::stream & stream_a) +{ + assert (header.type == nano::message_type::keepalive); + auto error (false); + for (auto i (peers.begin ()), j (peers.end ()); i != j && !error; ++i) + { + std::array address; + uint16_t port; + if (!read (stream_a, address) && !read (stream_a, port)) + { + *i = nano::endpoint (boost::asio::ip::address_v6 (address), port); + } + else + { + error = true; + } + } + return error; +} + +bool nano::keepalive::operator== (nano::keepalive const & other_a) const +{ + return peers == other_a.peers; +} + +nano::publish::publish (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a, nano::block_uniquer * uniquer_a) : +message (header_a) +{ + if (!error_a) + { + error_a = deserialize (stream_a, uniquer_a); + } +} + +nano::publish::publish (std::shared_ptr block_a) : +message (nano::message_type::publish), +block (block_a) +{ + header.block_type_set (block->type ()); +} + +bool nano::publish::deserialize (nano::stream & stream_a, nano::block_uniquer * uniquer_a) +{ + assert (header.type == nano::message_type::publish); + block = nano::deserialize_block (stream_a, header.block_type (), uniquer_a); + auto result (block == nullptr); + return result; +} + +void nano::publish::serialize (nano::stream & stream_a) const +{ + assert (block != nullptr); + header.serialize (stream_a); + block->serialize (stream_a); +} + +void nano::publish::visit (nano::message_visitor & visitor_a) const +{ + visitor_a.publish (*this); +} + +bool nano::publish::operator== (nano::publish const & other_a) const +{ + return *block == *other_a.block; +} + +nano::confirm_req::confirm_req (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a, nano::block_uniquer * uniquer_a) : +message (header_a) +{ + if (!error_a) + { + error_a = deserialize (stream_a, uniquer_a); + } +} + +nano::confirm_req::confirm_req (std::shared_ptr block_a) : +message (nano::message_type::confirm_req), +block (block_a) +{ + header.block_type_set (block->type ()); +} + +bool nano::confirm_req::deserialize (nano::stream & stream_a, nano::block_uniquer * uniquer_a) +{ + assert (header.type == nano::message_type::confirm_req); + block = nano::deserialize_block (stream_a, header.block_type (), uniquer_a); + auto result (block == nullptr); + return result; +} + +void nano::confirm_req::visit (nano::message_visitor & visitor_a) const +{ + visitor_a.confirm_req (*this); +} + +void nano::confirm_req::serialize (nano::stream & stream_a) const +{ + assert (block != nullptr); + header.serialize (stream_a); + block->serialize (stream_a); +} + +bool nano::confirm_req::operator== (nano::confirm_req const & other_a) const +{ + return *block == *other_a.block; +} + +nano::confirm_ack::confirm_ack (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a, nano::vote_uniquer * uniquer_a) : +message (header_a), +vote (std::make_shared (error_a, stream_a, header.block_type ())) +{ + if (uniquer_a) + { + vote = uniquer_a->unique (vote); + } +} + +nano::confirm_ack::confirm_ack (std::shared_ptr vote_a) : +message (nano::message_type::confirm_ack), +vote (vote_a) +{ + auto & first_vote_block (vote_a->blocks[0]); + if (first_vote_block.which ()) + { + header.block_type_set (nano::block_type::not_a_block); + } + else + { + header.block_type_set (boost::get> (first_vote_block)->type ()); + } +} + +bool nano::confirm_ack::deserialize (nano::stream & stream_a, nano::vote_uniquer * uniquer_a) +{ + assert (header.type == nano::message_type::confirm_ack); + auto result (vote->deserialize (stream_a)); + if (uniquer_a) + { + vote = uniquer_a->unique (vote); + } + return result; +} + +void nano::confirm_ack::serialize (nano::stream & stream_a) const +{ + assert (header.block_type () == nano::block_type::not_a_block || header.block_type () == nano::block_type::send || header.block_type () == nano::block_type::receive || header.block_type () == nano::block_type::open || header.block_type () == nano::block_type::change || header.block_type () == nano::block_type::state); + header.serialize (stream_a); + vote->serialize (stream_a, header.block_type ()); +} + +bool nano::confirm_ack::operator== (nano::confirm_ack const & other_a) const +{ + auto result (*vote == *other_a.vote); + return result; +} + +void nano::confirm_ack::visit (nano::message_visitor & visitor_a) const +{ + visitor_a.confirm_ack (*this); +} + +nano::frontier_req::frontier_req () : +message (nano::message_type::frontier_req) +{ +} + +nano::frontier_req::frontier_req (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) : +message (header_a) +{ + if (!error_a) + { + error_a = deserialize (stream_a); + } +} + +bool nano::frontier_req::deserialize (nano::stream & stream_a) +{ + assert (header.type == nano::message_type::frontier_req); + auto result (read (stream_a, start.bytes)); + if (!result) + { + result = read (stream_a, age); + if (!result) + { + result = read (stream_a, count); + } + } + return result; +} + +void nano::frontier_req::serialize (nano::stream & stream_a) const +{ + header.serialize (stream_a); + write (stream_a, start.bytes); + write (stream_a, age); + write (stream_a, count); +} + +void nano::frontier_req::visit (nano::message_visitor & visitor_a) const +{ + visitor_a.frontier_req (*this); +} + +bool nano::frontier_req::operator== (nano::frontier_req const & other_a) const +{ + return start == other_a.start && age == other_a.age && count == other_a.count; +} + +nano::bulk_pull::bulk_pull () : +message (nano::message_type::bulk_pull), +count (0) +{ +} + +nano::bulk_pull::bulk_pull (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) : +message (header_a), +count (0) +{ + if (!error_a) + { + error_a = deserialize (stream_a); + } +} + +void nano::bulk_pull::visit (nano::message_visitor & visitor_a) const +{ + visitor_a.bulk_pull (*this); +} + +bool nano::bulk_pull::deserialize (nano::stream & stream_a) +{ + assert (header.type == nano::message_type::bulk_pull); + auto result (read (stream_a, start)); + if (!result) + { + result = read (stream_a, end); + + if (!result) + { + if (is_count_present ()) + { + std::array count_buffer; + static_assert (sizeof (count) < (count_buffer.size () - 1), "count must fit within buffer"); + + result = read (stream_a, count_buffer); + if (count_buffer[0] != 0) + { + result = true; + } + else + { + memcpy (&count, count_buffer.data () + 1, sizeof (count)); + boost::endian::little_to_native_inplace (count); + } + } + else + { + count = 0; + } + } + } + return result; +} + +void nano::bulk_pull::serialize (nano::stream & stream_a) const +{ + /* + * Ensure the "count_present" flag is set if there + * is a limit specifed. Additionally, do not allow + * the "count_present" flag with a value of 0, since + * that is a sentinel which we use to mean "all blocks" + * and that is the behavior of not having the flag set + * so it is wasteful to do this. + */ + assert ((count == 0 && !is_count_present ()) || (count != 0 && is_count_present ())); + + header.serialize (stream_a); + write (stream_a, start); + write (stream_a, end); + + if (is_count_present ()) + { + std::array count_buffer{ { 0 } }; + decltype (count) count_little_endian; + static_assert (sizeof (count_little_endian) < (count_buffer.size () - 1), "count must fit within buffer"); + + count_little_endian = boost::endian::native_to_little (count); + memcpy (count_buffer.data () + 1, &count_little_endian, sizeof (count_little_endian)); + + write (stream_a, count_buffer); + } +} + +bool nano::bulk_pull::is_count_present () const +{ + return header.extensions.test (count_present_flag); +} + +void nano::bulk_pull::set_count_present (bool value_a) +{ + header.extensions.set (count_present_flag, value_a); +} + +nano::bulk_pull_account::bulk_pull_account () : +message (nano::message_type::bulk_pull_account) +{ +} + +nano::bulk_pull_account::bulk_pull_account (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) : +message (header_a) +{ + if (!error_a) + { + error_a = deserialize (stream_a); + } +} + +void nano::bulk_pull_account::visit (nano::message_visitor & visitor_a) const +{ + visitor_a.bulk_pull_account (*this); +} + +bool nano::bulk_pull_account::deserialize (nano::stream & stream_a) +{ + assert (header.type == nano::message_type::bulk_pull_account); + auto result (read (stream_a, account)); + if (!result) + { + result = read (stream_a, minimum_amount); + if (!result) + { + result = read (stream_a, flags); + } + } + return result; +} + +void nano::bulk_pull_account::serialize (nano::stream & stream_a) const +{ + header.serialize (stream_a); + write (stream_a, account); + write (stream_a, minimum_amount); + write (stream_a, flags); +} + +nano::bulk_pull_blocks::bulk_pull_blocks () : +message (nano::message_type::bulk_pull_blocks) +{ +} + +nano::bulk_pull_blocks::bulk_pull_blocks (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) : +message (header_a) +{ + if (!error_a) + { + error_a = deserialize (stream_a); + } +} + +void nano::bulk_pull_blocks::visit (nano::message_visitor & visitor_a) const +{ + visitor_a.bulk_pull_blocks (*this); +} + +bool nano::bulk_pull_blocks::deserialize (nano::stream & stream_a) +{ + assert (header.type == nano::message_type::bulk_pull_blocks); + auto result (read (stream_a, min_hash)); + if (!result) + { + result = read (stream_a, max_hash); + if (!result) + { + result = read (stream_a, mode); + if (!result) + { + result = read (stream_a, max_count); + } + } + } + return result; +} + +void nano::bulk_pull_blocks::serialize (nano::stream & stream_a) const +{ + header.serialize (stream_a); + write (stream_a, min_hash); + write (stream_a, max_hash); + write (stream_a, mode); + write (stream_a, max_count); +} + +nano::bulk_push::bulk_push () : +message (nano::message_type::bulk_push) +{ +} + +nano::bulk_push::bulk_push (nano::message_header const & header_a) : +message (header_a) +{ +} + +bool nano::bulk_push::deserialize (nano::stream & stream_a) +{ + assert (header.type == nano::message_type::bulk_push); + return false; +} + +void nano::bulk_push::serialize (nano::stream & stream_a) const +{ + header.serialize (stream_a); +} + +void nano::bulk_push::visit (nano::message_visitor & visitor_a) const +{ + visitor_a.bulk_push (*this); +} + +size_t constexpr nano::node_id_handshake::query_flag; +size_t constexpr nano::node_id_handshake::response_flag; + +nano::node_id_handshake::node_id_handshake (bool & error_a, nano::stream & stream_a, nano::message_header const & header_a) : +message (header_a), +query (boost::none), +response (boost::none) +{ + error_a = deserialize (stream_a); +} + +nano::node_id_handshake::node_id_handshake (boost::optional query, boost::optional> response) : +message (nano::message_type::node_id_handshake), +query (query), +response (response) +{ + if (query) + { + set_query_flag (true); + } + if (response) + { + set_response_flag (true); + } +} + +bool nano::node_id_handshake::deserialize (nano::stream & stream_a) +{ + auto result (false); + assert (header.type == nano::message_type::node_id_handshake); + if (!result && is_query_flag ()) + { + nano::uint256_union query_hash; + result = read (stream_a, query_hash); + if (!result) + { + query = query_hash; + } + } + if (!result && is_response_flag ()) + { + nano::account response_account; + result = read (stream_a, response_account); + if (!result) + { + nano::signature response_signature; + result = read (stream_a, response_signature); + if (!result) + { + response = std::make_pair (response_account, response_signature); + } + } + } + return result; +} + +void nano::node_id_handshake::serialize (nano::stream & stream_a) const +{ + header.serialize (stream_a); + if (query) + { + write (stream_a, *query); + } + if (response) + { + write (stream_a, response->first); + write (stream_a, response->second); + } +} + +bool nano::node_id_handshake::operator== (nano::node_id_handshake const & other_a) const +{ + auto result (*query == *other_a.query && *response == *other_a.response); + return result; +} + +bool nano::node_id_handshake::is_query_flag () const +{ + return header.extensions.test (query_flag); +} + +void nano::node_id_handshake::set_query_flag (bool value_a) +{ + header.extensions.set (query_flag, value_a); +} + +bool nano::node_id_handshake::is_response_flag () const +{ + return header.extensions.test (response_flag); +} + +void nano::node_id_handshake::set_response_flag (bool value_a) +{ + header.extensions.set (response_flag, value_a); +} + +void nano::node_id_handshake::visit (nano::message_visitor & visitor_a) const +{ + visitor_a.node_id_handshake (*this); +} + +nano::message_visitor::~message_visitor () +{ +} + +bool nano::parse_port (std::string const & string_a, uint16_t & port_a) +{ + bool result; + size_t converted; + try + { + port_a = std::stoul (string_a, &converted); + result = converted != string_a.size () || converted > std::numeric_limits::max (); + } + catch (...) + { + result = true; + } + return result; +} + +bool nano::parse_address_port (std::string const & string, boost::asio::ip::address & address_a, uint16_t & port_a) +{ + auto result (false); + auto port_position (string.rfind (':')); + if (port_position != std::string::npos && port_position > 0) + { + std::string port_string (string.substr (port_position + 1)); + try + { + uint16_t port; + result = parse_port (port_string, port); + if (!result) + { + boost::system::error_code ec; + auto address (boost::asio::ip::address_v6::from_string (string.substr (0, port_position), ec)); + if (!ec) + { + address_a = address; + port_a = port; + } + else + { + result = true; + } + } + else + { + result = true; + } + } + catch (...) + { + result = true; + } + } + else + { + result = true; + } + return result; +} + +bool nano::parse_endpoint (std::string const & string, nano::endpoint & endpoint_a) +{ + boost::asio::ip::address address; + uint16_t port; + auto result (parse_address_port (string, address, port)); + if (!result) + { + endpoint_a = nano::endpoint (address, port); + } + return result; +} + +bool nano::parse_tcp_endpoint (std::string const & string, nano::tcp_endpoint & endpoint_a) +{ + boost::asio::ip::address address; + uint16_t port; + auto result (parse_address_port (string, address, port)); + if (!result) + { + endpoint_a = nano::tcp_endpoint (address, port); + } + return result; +} diff --git a/nano/node/common.hpp b/nano/node/common.hpp new file mode 100644 index 00000000..0af80fa5 --- /dev/null +++ b/nano/node/common.hpp @@ -0,0 +1,398 @@ +#pragma once + +#include +#include + +#include + +#include + +#include + +namespace nano +{ +using endpoint = boost::asio::ip::udp::endpoint; +bool parse_port (std::string const &, uint16_t &); +bool parse_address_port (std::string const &, boost::asio::ip::address &, uint16_t &); +using tcp_endpoint = boost::asio::ip::tcp::endpoint; +bool parse_endpoint (std::string const &, nano::endpoint &); +bool parse_tcp_endpoint (std::string const &, nano::tcp_endpoint &); +bool reserved_address (nano::endpoint const &, bool); +} + +namespace +{ +uint64_t endpoint_hash_raw (nano::endpoint const & endpoint_a) +{ + assert (endpoint_a.address ().is_v6 ()); + nano::uint128_union address; + address.bytes = endpoint_a.address ().to_v6 ().to_bytes (); + XXH64_state_t hash; + XXH64_reset (&hash, 0); + XXH64_update (&hash, address.bytes.data (), address.bytes.size ()); + auto port (endpoint_a.port ()); + XXH64_update (&hash, &port, sizeof (port)); + auto result (XXH64_digest (&hash)); + return result; +} +uint64_t ip_address_hash_raw (boost::asio::ip::address const & ip_a) +{ + assert (ip_a.is_v6 ()); + nano::uint128_union bytes; + bytes.bytes = ip_a.to_v6 ().to_bytes (); + XXH64_state_t hash; + XXH64_reset (&hash, 0); + XXH64_update (&hash, bytes.bytes.data (), bytes.bytes.size ()); + auto result (XXH64_digest (&hash)); + return result; +} + +template +struct endpoint_hash +{ +}; +template <> +struct endpoint_hash<8> +{ + size_t operator() (nano::endpoint const & endpoint_a) const + { + return endpoint_hash_raw (endpoint_a); + } +}; +template <> +struct endpoint_hash<4> +{ + size_t operator() (nano::endpoint const & endpoint_a) const + { + uint64_t big (endpoint_hash_raw (endpoint_a)); + uint32_t result (static_cast (big) ^ static_cast (big >> 32)); + return result; + } +}; +} + +namespace std +{ +template <> +struct hash<::nano::endpoint> +{ + size_t operator() (::nano::endpoint const & endpoint_a) const + { + endpoint_hash ehash; + return ehash (endpoint_a); + } +}; +template +struct ip_address_hash +{ +}; +template <> +struct ip_address_hash<8> +{ + size_t operator() (boost::asio::ip::address const & ip_address_a) const + { + return ip_address_hash_raw (ip_address_a); + } +}; +template <> +struct ip_address_hash<4> +{ + size_t operator() (boost::asio::ip::address const & ip_address_a) const + { + uint64_t big (ip_address_hash_raw (ip_address_a)); + uint32_t result (static_cast (big) ^ static_cast (big >> 32)); + return result; + } +}; +template <> +struct hash +{ + size_t operator() (boost::asio::ip::address const & ip_a) const + { + ip_address_hash ihash; + return ihash (ip_a); + } +}; +} +namespace boost +{ +template <> +struct hash<::nano::endpoint> +{ + size_t operator() (::nano::endpoint const & endpoint_a) const + { + std::hash<::nano::endpoint> hash; + return hash (endpoint_a); + } +}; +} + +namespace nano +{ +/** + * Message types are serialized to the network and existing values must thus never change as + * types are added, removed and reordered in the enum. + */ +enum class message_type : uint8_t +{ + invalid = 0x0, + not_a_type = 0x1, + keepalive = 0x2, + publish = 0x3, + confirm_req = 0x4, + confirm_ack = 0x5, + bulk_pull = 0x6, + bulk_push = 0x7, + frontier_req = 0x8, + bulk_pull_blocks = 0x9, + node_id_handshake = 0x0a, + bulk_pull_account = 0x0b +}; +enum class bulk_pull_blocks_mode : uint8_t +{ + list_blocks, + checksum_blocks +}; +enum class bulk_pull_account_flags : uint8_t +{ + pending_hash_and_amount = 0x0, + pending_address_only = 0x1, + pending_hash_amount_and_address = 0x2 +}; +class message_visitor; +class message_header +{ +public: + message_header (nano::message_type); + message_header (bool &, nano::stream &); + void serialize (nano::stream &) const; + bool deserialize (nano::stream &); + nano::block_type block_type () const; + void block_type_set (nano::block_type); + static std::array constexpr magic_number = nano::nano_network == nano::nano_networks::nano_test_network ? std::array{ { 'R', 'A' } } : nano::nano_network == nano::nano_networks::nano_beta_network ? std::array{ { 'R', 'B' } } : std::array{ { 'R', 'C' } }; + uint8_t version_max; + uint8_t version_using; + uint8_t version_min; + nano::message_type type; + std::bitset<16> extensions; + //static size_t constexpr ipv4_only_position = 1; // Not in use, deprecated, was conflicting + //static size_t constexpr bootstrap_server_position = 2; // Not in use, deprecated + /* + * A better approach might be to return the size of the message + * payload based on the header + */ + static size_t constexpr bulk_pull_count_present_flag = 0; + bool bulk_pull_is_count_present () const; + + static std::bitset<16> constexpr block_type_mask = std::bitset<16> (0x0f00); + inline bool valid_magic () const + { + return magic_number[0] == 'R' && magic_number[1] >= 'A' && magic_number[1] <= 'C'; + } + inline bool valid_network () const + { + return (magic_number[1] - 'A') == static_cast (nano::nano_network); + } +}; +class message +{ +public: + message (nano::message_type); + message (nano::message_header const &); + virtual ~message () = default; + virtual void serialize (nano::stream &) const = 0; + virtual void visit (nano::message_visitor &) const = 0; + virtual inline std::shared_ptr> to_bytes () const + { + std::shared_ptr> bytes (new std::vector); + nano::vectorstream stream (*bytes); + serialize (stream); + return bytes; + } + nano::message_header header; +}; +class work_pool; +class message_parser +{ +public: + enum class parse_status + { + success, + insufficient_work, + invalid_header, + invalid_message_type, + invalid_keepalive_message, + invalid_publish_message, + invalid_confirm_req_message, + invalid_confirm_ack_message, + invalid_node_id_handshake_message, + outdated_version, + invalid_magic, + invalid_network + }; + message_parser (nano::block_uniquer &, nano::vote_uniquer &, nano::message_visitor &, nano::work_pool &); + void deserialize_buffer (uint8_t const *, size_t); + void deserialize_keepalive (nano::stream &, nano::message_header const &); + void deserialize_publish (nano::stream &, nano::message_header const &); + void deserialize_confirm_req (nano::stream &, nano::message_header const &); + void deserialize_confirm_ack (nano::stream &, nano::message_header const &); + void deserialize_node_id_handshake (nano::stream &, nano::message_header const &); + bool at_end (nano::stream &); + nano::block_uniquer & block_uniquer; + nano::vote_uniquer & vote_uniquer; + nano::message_visitor & visitor; + nano::work_pool & pool; + parse_status status; + std::string status_string (); + static const size_t max_safe_udp_message_size; +}; +class keepalive : public message +{ +public: + keepalive (bool &, nano::stream &, nano::message_header const &); + keepalive (); + void visit (nano::message_visitor &) const override; + bool deserialize (nano::stream &); + void serialize (nano::stream &) const override; + bool operator== (nano::keepalive const &) const; + std::array peers; +}; +class publish : public message +{ +public: + publish (bool &, nano::stream &, nano::message_header const &, nano::block_uniquer * = nullptr); + publish (std::shared_ptr); + void visit (nano::message_visitor &) const override; + bool deserialize (nano::stream &, nano::block_uniquer * = nullptr); + void serialize (nano::stream &) const override; + bool operator== (nano::publish const &) const; + std::shared_ptr block; +}; +class confirm_req : public message +{ +public: + confirm_req (bool &, nano::stream &, nano::message_header const &, nano::block_uniquer * = nullptr); + confirm_req (std::shared_ptr); + bool deserialize (nano::stream &, nano::block_uniquer * = nullptr); + void serialize (nano::stream &) const override; + void visit (nano::message_visitor &) const override; + bool operator== (nano::confirm_req const &) const; + std::shared_ptr block; +}; +class confirm_ack : public message +{ +public: + confirm_ack (bool &, nano::stream &, nano::message_header const &, nano::vote_uniquer * = nullptr); + confirm_ack (std::shared_ptr); + bool deserialize (nano::stream &, nano::vote_uniquer * = nullptr); + void serialize (nano::stream &) const override; + void visit (nano::message_visitor &) const override; + bool operator== (nano::confirm_ack const &) const; + std::shared_ptr vote; +}; +class frontier_req : public message +{ +public: + frontier_req (); + frontier_req (bool &, nano::stream &, nano::message_header const &); + bool deserialize (nano::stream &); + void serialize (nano::stream &) const override; + void visit (nano::message_visitor &) const override; + bool operator== (nano::frontier_req const &) const; + nano::account start; + uint32_t age; + uint32_t count; +}; +class bulk_pull : public message +{ +public: + typedef uint32_t count_t; + bulk_pull (); + bulk_pull (bool &, nano::stream &, nano::message_header const &); + bool deserialize (nano::stream &); + void serialize (nano::stream &) const override; + void visit (nano::message_visitor &) const override; + nano::uint256_union start; + nano::block_hash end; + count_t count; + bool is_count_present () const; + void set_count_present (bool); + static size_t constexpr count_present_flag = nano::message_header::bulk_pull_count_present_flag; + static size_t constexpr extended_parameters_size = 8; +}; +class bulk_pull_account : public message +{ +public: + bulk_pull_account (); + bulk_pull_account (bool &, nano::stream &, nano::message_header const &); + bool deserialize (nano::stream &); + void serialize (nano::stream &) const override; + void visit (nano::message_visitor &) const override; + nano::uint256_union account; + nano::uint128_union minimum_amount; + bulk_pull_account_flags flags; +}; +class bulk_pull_blocks : public message +{ +public: + bulk_pull_blocks (); + bulk_pull_blocks (bool &, nano::stream &, nano::message_header const &); + bool deserialize (nano::stream &); + void serialize (nano::stream &) const override; + void visit (nano::message_visitor &) const override; + nano::block_hash min_hash; + nano::block_hash max_hash; + bulk_pull_blocks_mode mode; + uint32_t max_count; +}; +class bulk_push : public message +{ +public: + bulk_push (); + bulk_push (nano::message_header const &); + bool deserialize (nano::stream &); + void serialize (nano::stream &) const override; + void visit (nano::message_visitor &) const override; +}; +class node_id_handshake : public message +{ +public: + node_id_handshake (bool &, nano::stream &, nano::message_header const &); + node_id_handshake (boost::optional, boost::optional>); + bool deserialize (nano::stream &); + void serialize (nano::stream &) const override; + void visit (nano::message_visitor &) const override; + bool operator== (nano::node_id_handshake const &) const; + bool is_query_flag () const; + void set_query_flag (bool); + bool is_response_flag () const; + void set_response_flag (bool); + boost::optional query; + boost::optional> response; + static size_t constexpr query_flag = 0; + static size_t constexpr response_flag = 1; +}; +class message_visitor +{ +public: + virtual void keepalive (nano::keepalive const &) = 0; + virtual void publish (nano::publish const &) = 0; + virtual void confirm_req (nano::confirm_req const &) = 0; + virtual void confirm_ack (nano::confirm_ack const &) = 0; + virtual void bulk_pull (nano::bulk_pull const &) = 0; + virtual void bulk_pull_account (nano::bulk_pull_account const &) = 0; + virtual void bulk_pull_blocks (nano::bulk_pull_blocks const &) = 0; + virtual void bulk_push (nano::bulk_push const &) = 0; + virtual void frontier_req (nano::frontier_req const &) = 0; + virtual void node_id_handshake (nano::node_id_handshake const &) = 0; + virtual ~message_visitor (); +}; + +/** + * Returns seconds passed since unix epoch (posix time) + */ +inline uint64_t seconds_since_epoch () +{ + return std::chrono::duration_cast (std::chrono::system_clock::now ().time_since_epoch ()).count (); +} +} diff --git a/nano/node/lmdb.cpp b/nano/node/lmdb.cpp new file mode 100644 index 00000000..e085d705 --- /dev/null +++ b/nano/node/lmdb.cpp @@ -0,0 +1,1992 @@ +#include + +#include +#include +#include + +#include + +#include + +nano::mdb_env::mdb_env (bool & error_a, boost::filesystem::path const & path_a, int max_dbs) +{ + boost::system::error_code error_mkdir, error_chmod; + if (path_a.has_parent_path ()) + { + boost::filesystem::create_directories (path_a.parent_path (), error_mkdir); + nano::set_secure_perm_directory (path_a.parent_path (), error_chmod); + if (!error_mkdir) + { + auto status1 (mdb_env_create (&environment)); + release_assert (status1 == 0); + auto status2 (mdb_env_set_maxdbs (environment, max_dbs)); + release_assert (status2 == 0); + auto status3 (mdb_env_set_mapsize (environment, 1ULL * 1024 * 1024 * 1024 * 128)); // 128 Gigabyte + release_assert (status3 == 0); + // It seems if there's ever more threads than mdb_env_set_maxreaders has read slots available, we get failures on transaction creation unless MDB_NOTLS is specified + // This can happen if something like 256 io_threads are specified in the node config + auto status4 (mdb_env_open (environment, path_a.string ().c_str (), MDB_NOSUBDIR | MDB_NOTLS, 00600)); + release_assert (status4 == 0); + error_a = status4 != 0; + } + else + { + error_a = true; + environment = nullptr; + } + } + else + { + error_a = true; + environment = nullptr; + } +} + +nano::mdb_env::~mdb_env () +{ + if (environment != nullptr) + { + mdb_env_close (environment); + } +} + +nano::mdb_env::operator MDB_env * () const +{ + return environment; +} + +nano::transaction nano::mdb_env::tx_begin (bool write_a) const +{ + return { std::make_unique (*this, write_a) }; +} + +MDB_txn * nano::mdb_env::tx (nano::transaction const & transaction_a) const +{ + auto result (boost::polymorphic_downcast (transaction_a.impl.get ())); + release_assert (mdb_txn_env (result->handle) == environment); + return *result; +} + +nano::mdb_val::mdb_val (nano::epoch epoch_a) : +value ({ 0, nullptr }), +epoch (epoch_a) +{ +} + +nano::mdb_val::mdb_val (MDB_val const & value_a, nano::epoch epoch_a) : +value (value_a), +epoch (epoch_a) +{ +} + +nano::mdb_val::mdb_val (size_t size_a, void * data_a) : +value ({ size_a, data_a }) +{ +} + +nano::mdb_val::mdb_val (nano::uint128_union const & val_a) : +mdb_val (sizeof (val_a), const_cast (&val_a)) +{ +} + +nano::mdb_val::mdb_val (nano::uint256_union const & val_a) : +mdb_val (sizeof (val_a), const_cast (&val_a)) +{ +} + +nano::mdb_val::mdb_val (nano::account_info const & val_a) : +mdb_val (val_a.db_size (), const_cast (&val_a)) +{ +} + +nano::mdb_val::mdb_val (nano::pending_info const & val_a) : +mdb_val (sizeof (val_a.source) + sizeof (val_a.amount), const_cast (&val_a)) +{ +} + +nano::mdb_val::mdb_val (nano::pending_key const & val_a) : +mdb_val (sizeof (val_a), const_cast (&val_a)) +{ +} + +nano::mdb_val::mdb_val (nano::block_info const & val_a) : +mdb_val (sizeof (val_a), const_cast (&val_a)) +{ +} + +nano::mdb_val::mdb_val (std::shared_ptr const & val_a) : +buffer (std::make_shared> ()) +{ + { + nano::vectorstream stream (*buffer); + nano::serialize_block (stream, *val_a); + } + value = { buffer->size (), const_cast (buffer->data ()) }; +} + +void * nano::mdb_val::data () const +{ + return value.mv_data; +} + +size_t nano::mdb_val::size () const +{ + return value.mv_size; +} + +nano::mdb_val::operator nano::account_info () const +{ + nano::account_info result; + result.epoch = epoch; + assert (value.mv_size == result.db_size ()); + std::copy (reinterpret_cast (value.mv_data), reinterpret_cast (value.mv_data) + result.db_size (), reinterpret_cast (&result)); + return result; +} + +nano::mdb_val::operator nano::block_info () const +{ + nano::block_info result; + assert (value.mv_size == sizeof (result)); + static_assert (sizeof (nano::block_info::account) + sizeof (nano::block_info::balance) == sizeof (result), "Packed class"); + std::copy (reinterpret_cast (value.mv_data), reinterpret_cast (value.mv_data) + sizeof (result), reinterpret_cast (&result)); + return result; +} + +nano::mdb_val::operator nano::pending_info () const +{ + nano::pending_info result; + result.epoch = epoch; + std::copy (reinterpret_cast (value.mv_data), reinterpret_cast (value.mv_data) + sizeof (nano::pending_info::source) + sizeof (nano::pending_info::amount), reinterpret_cast (&result)); + return result; +} + +nano::mdb_val::operator nano::pending_key () const +{ + nano::pending_key result; + assert (value.mv_size == sizeof (result)); + static_assert (sizeof (nano::pending_key::account) + sizeof (nano::pending_key::hash) == sizeof (result), "Packed class"); + std::copy (reinterpret_cast (value.mv_data), reinterpret_cast (value.mv_data) + sizeof (result), reinterpret_cast (&result)); + return result; +} + +nano::mdb_val::operator nano::uint128_union () const +{ + nano::uint128_union result; + assert (size () == sizeof (result)); + std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + sizeof (result), result.bytes.data ()); + return result; +} + +nano::mdb_val::operator nano::uint256_union () const +{ + nano::uint256_union result; + assert (size () == sizeof (result)); + std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + sizeof (result), result.bytes.data ()); + return result; +} + +nano::mdb_val::operator std::array () const +{ + nano::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); + std::array result; + nano::read (stream, result); + return result; +} + +nano::mdb_val::operator no_value () const +{ + return no_value::dummy; +} + +nano::mdb_val::operator std::shared_ptr () const +{ + nano::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); + std::shared_ptr result (nano::deserialize_block (stream)); + return result; +} + +nano::mdb_val::operator std::shared_ptr () const +{ + nano::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); + auto error (false); + std::shared_ptr result (std::make_shared (error, stream)); + assert (!error); + return result; +} + +nano::mdb_val::operator std::shared_ptr () const +{ + nano::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); + auto error (false); + std::shared_ptr result (std::make_shared (error, stream)); + assert (!error); + return result; +} + +nano::mdb_val::operator std::shared_ptr () const +{ + nano::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); + auto error (false); + std::shared_ptr result (std::make_shared (error, stream)); + assert (!error); + return result; +} + +nano::mdb_val::operator std::shared_ptr () const +{ + nano::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); + auto error (false); + std::shared_ptr result (std::make_shared (error, stream)); + assert (!error); + return result; +} + +nano::mdb_val::operator std::shared_ptr () const +{ + nano::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); + auto error (false); + std::shared_ptr result (std::make_shared (error, stream)); + assert (!error); + return result; +} + +nano::mdb_val::operator std::shared_ptr () const +{ + nano::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); + auto error (false); + std::shared_ptr result (std::make_shared (error, stream)); + assert (!error); + return result; +} + +nano::mdb_val::operator uint64_t () const +{ + uint64_t result; + nano::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); + auto error (nano::read (stream, result)); + assert (!error); + return result; +} + +nano::mdb_val::operator MDB_val * () const +{ + // Allow passing a temporary to a non-c++ function which doesn't have constness + return const_cast (&value); +}; + +nano::mdb_val::operator MDB_val const & () const +{ + return value; +} + +nano::mdb_txn::mdb_txn (nano::mdb_env const & environment_a, bool write_a) +{ + auto status (mdb_txn_begin (environment_a, nullptr, write_a ? 0 : MDB_RDONLY, &handle)); + release_assert (status == 0); +} + +nano::mdb_txn::~mdb_txn () +{ + auto status (mdb_txn_commit (handle)); + release_assert (status == 0); +} + +nano::mdb_txn::operator MDB_txn * () const +{ + return handle; +} + +namespace nano +{ +/** + * Fill in our predecessors + */ +class block_predecessor_set : public nano::block_visitor +{ +public: + block_predecessor_set (nano::transaction const & transaction_a, nano::mdb_store & store_a) : + transaction (transaction_a), + store (store_a) + { + } + virtual ~block_predecessor_set () = default; + void fill_value (nano::block const & block_a) + { + auto hash (block_a.hash ()); + nano::block_type type; + auto value (store.block_raw_get (transaction, block_a.previous (), type)); + auto version (store.block_version (transaction, block_a.previous ())); + assert (value.mv_size != 0); + std::vector data (static_cast (value.mv_data), static_cast (value.mv_data) + value.mv_size); + std::copy (hash.bytes.begin (), hash.bytes.end (), data.end () - hash.bytes.size ()); + store.block_raw_put (transaction, store.block_database (type, version), block_a.previous (), nano::mdb_val (data.size (), data.data ())); + } + void send_block (nano::send_block const & block_a) override + { + fill_value (block_a); + } + void receive_block (nano::receive_block const & block_a) override + { + fill_value (block_a); + } + void open_block (nano::open_block const & block_a) override + { + // Open blocks don't have a predecessor + } + void change_block (nano::change_block const & block_a) override + { + fill_value (block_a); + } + void state_block (nano::state_block const & block_a) override + { + if (!block_a.previous ().is_zero ()) + { + fill_value (block_a); + } + } + nano::transaction const & transaction; + nano::mdb_store & store; +}; +} + +template +nano::mdb_iterator::mdb_iterator (nano::transaction const & transaction_a, MDB_dbi db_a, nano::epoch epoch_a) : +cursor (nullptr) +{ + current.first.epoch = epoch_a; + current.second.epoch = epoch_a; + auto status (mdb_cursor_open (tx (transaction_a), db_a, &cursor)); + release_assert (status == 0); + auto status2 (mdb_cursor_get (cursor, ¤t.first.value, ¤t.second.value, MDB_FIRST)); + release_assert (status2 == 0 || status2 == MDB_NOTFOUND); + if (status2 != MDB_NOTFOUND) + { + auto status3 (mdb_cursor_get (cursor, ¤t.first.value, ¤t.second.value, MDB_GET_CURRENT)); + release_assert (status3 == 0 || status3 == MDB_NOTFOUND); + if (current.first.size () != sizeof (T)) + { + clear (); + } + } + else + { + clear (); + } +} + +template +nano::mdb_iterator::mdb_iterator (std::nullptr_t, nano::epoch epoch_a) : +cursor (nullptr) +{ + current.first.epoch = epoch_a; + current.second.epoch = epoch_a; +} + +template +nano::mdb_iterator::mdb_iterator (nano::transaction const & transaction_a, MDB_dbi db_a, MDB_val const & val_a, nano::epoch epoch_a) : +cursor (nullptr) +{ + current.first.epoch = epoch_a; + current.second.epoch = epoch_a; + auto status (mdb_cursor_open (tx (transaction_a), db_a, &cursor)); + release_assert (status == 0); + current.first = val_a; + auto status2 (mdb_cursor_get (cursor, ¤t.first.value, ¤t.second.value, MDB_SET_RANGE)); + release_assert (status2 == 0 || status2 == MDB_NOTFOUND); + if (status2 != MDB_NOTFOUND) + { + auto status3 (mdb_cursor_get (cursor, ¤t.first.value, ¤t.second.value, MDB_GET_CURRENT)); + release_assert (status3 == 0 || status3 == MDB_NOTFOUND); + if (current.first.size () != sizeof (T)) + { + clear (); + } + } + else + { + clear (); + } +} + +template +nano::mdb_iterator::mdb_iterator (nano::mdb_iterator && other_a) +{ + cursor = other_a.cursor; + other_a.cursor = nullptr; + current = other_a.current; +} + +template +nano::mdb_iterator::~mdb_iterator () +{ + if (cursor != nullptr) + { + mdb_cursor_close (cursor); + } +} + +template +nano::store_iterator_impl & nano::mdb_iterator::operator++ () +{ + assert (cursor != nullptr); + auto status (mdb_cursor_get (cursor, ¤t.first.value, ¤t.second.value, MDB_NEXT)); + release_assert (status == 0 || status == MDB_NOTFOUND); + if (status == MDB_NOTFOUND) + { + clear (); + } + if (current.first.size () != sizeof (T)) + { + clear (); + } + return *this; +} + +template +nano::mdb_iterator & nano::mdb_iterator::operator= (nano::mdb_iterator && other_a) +{ + if (cursor != nullptr) + { + mdb_cursor_close (cursor); + } + cursor = other_a.cursor; + other_a.cursor = nullptr; + current = other_a.current; + other_a.clear (); + return *this; +} + +template +std::pair * nano::mdb_iterator::operator-> () +{ + return ¤t; +} + +template +bool nano::mdb_iterator::operator== (nano::store_iterator_impl const & base_a) const +{ + auto const other_a (boost::polymorphic_downcast const *> (&base_a)); + auto result (current.first.data () == other_a->current.first.data ()); + assert (!result || (current.first.size () == other_a->current.first.size ())); + assert (!result || (current.second.data () == other_a->current.second.data ())); + assert (!result || (current.second.size () == other_a->current.second.size ())); + return result; +} + +template +void nano::mdb_iterator::clear () +{ + current.first = nano::mdb_val (current.first.epoch); + current.second = nano::mdb_val (current.second.epoch); + assert (is_end_sentinal ()); +} + +template +MDB_txn * nano::mdb_iterator::tx (nano::transaction const & transaction_a) const +{ + auto result (boost::polymorphic_downcast (transaction_a.impl.get ())); + return *result; +} + +template +bool nano::mdb_iterator::is_end_sentinal () const +{ + return current.first.size () == 0; +} + +template +void nano::mdb_iterator::fill (std::pair & value_a) const +{ + if (current.first.size () != 0) + { + value_a.first = static_cast (current.first); + } + else + { + value_a.first = T (); + } + if (current.second.size () != 0) + { + value_a.second = static_cast (current.second); + } + else + { + value_a.second = U (); + } +} + +template +std::pair * nano::mdb_merge_iterator::operator-> () +{ + return least_iterator ().operator-> (); +} + +template +nano::mdb_merge_iterator::mdb_merge_iterator (nano::transaction const & transaction_a, MDB_dbi db1_a, MDB_dbi db2_a) : +impl1 (std::make_unique> (transaction_a, db1_a, nano::epoch::epoch_0)), +impl2 (std::make_unique> (transaction_a, db2_a, nano::epoch::epoch_1)) +{ +} + +template +nano::mdb_merge_iterator::mdb_merge_iterator (std::nullptr_t) : +impl1 (std::make_unique> (nullptr, nano::epoch::epoch_0)), +impl2 (std::make_unique> (nullptr, nano::epoch::epoch_1)) +{ +} + +template +nano::mdb_merge_iterator::mdb_merge_iterator (nano::transaction const & transaction_a, MDB_dbi db1_a, MDB_dbi db2_a, MDB_val const & val_a) : +impl1 (std::make_unique> (transaction_a, db1_a, val_a, nano::epoch::epoch_0)), +impl2 (std::make_unique> (transaction_a, db2_a, val_a, nano::epoch::epoch_1)) +{ +} + +template +nano::mdb_merge_iterator::mdb_merge_iterator (nano::mdb_merge_iterator && other_a) +{ + impl1 = std::move (other_a.impl1); + impl2 = std::move (other_a.impl2); +} + +template +nano::mdb_merge_iterator::~mdb_merge_iterator () +{ +} + +template +nano::store_iterator_impl & nano::mdb_merge_iterator::operator++ () +{ + ++least_iterator (); + return *this; +} + +template +bool nano::mdb_merge_iterator::is_end_sentinal () const +{ + return least_iterator ().is_end_sentinal (); +} + +template +void nano::mdb_merge_iterator::fill (std::pair & value_a) const +{ + auto & current (least_iterator ()); + if (current->first.size () != 0) + { + value_a.first = static_cast (current->first); + } + else + { + value_a.first = T (); + } + if (current->second.size () != 0) + { + value_a.second = static_cast (current->second); + } + else + { + value_a.second = U (); + } +} + +template +bool nano::mdb_merge_iterator::operator== (nano::store_iterator_impl const & base_a) const +{ + assert ((dynamic_cast const *> (&base_a) != nullptr) && "Incompatible iterator comparison"); + auto & other (static_cast const &> (base_a)); + return *impl1 == *other.impl1 && *impl2 == *other.impl2; +} + +template +nano::mdb_iterator & nano::mdb_merge_iterator::least_iterator () const +{ + nano::mdb_iterator * result; + if (impl1->is_end_sentinal ()) + { + result = impl2.get (); + } + else if (impl2->is_end_sentinal ()) + { + result = impl1.get (); + } + else + { + auto key_cmp (mdb_cmp (mdb_cursor_txn (impl1->cursor), mdb_cursor_dbi (impl1->cursor), impl1->current.first, impl2->current.first)); + + if (key_cmp < 0) + { + result = impl1.get (); + } + else if (key_cmp > 0) + { + result = impl2.get (); + } + else + { + auto val_cmp (mdb_cmp (mdb_cursor_txn (impl1->cursor), mdb_cursor_dbi (impl1->cursor), impl1->current.second, impl2->current.second)); + result = val_cmp < 0 ? impl1.get () : impl2.get (); + } + } + return *result; +} + +nano::wallet_value::wallet_value (nano::mdb_val const & val_a) +{ + assert (val_a.size () == sizeof (*this)); + std::copy (reinterpret_cast (val_a.data ()), reinterpret_cast (val_a.data ()) + sizeof (key), key.chars.begin ()); + std::copy (reinterpret_cast (val_a.data ()) + sizeof (key), reinterpret_cast (val_a.data ()) + sizeof (key) + sizeof (work), reinterpret_cast (&work)); +} + +nano::wallet_value::wallet_value (nano::uint256_union const & key_a, uint64_t work_a) : +key (key_a), +work (work_a) +{ +} + +nano::mdb_val nano::wallet_value::val () const +{ + static_assert (sizeof (*this) == sizeof (key) + sizeof (work), "Class not packed"); + return nano::mdb_val (sizeof (*this), const_cast (this)); +} + +template class nano::mdb_iterator; +template class nano::mdb_iterator; +template class nano::mdb_iterator; +template class nano::mdb_iterator; +template class nano::mdb_iterator>; +template class nano::mdb_iterator>; +template class nano::mdb_iterator; +template class nano::mdb_iterator, nano::mdb_val::no_value>; + +nano::store_iterator nano::mdb_store::block_info_begin (nano::transaction const & transaction_a, nano::block_hash const & hash_a) +{ + nano::store_iterator result (std::make_unique> (transaction_a, blocks_info, nano::mdb_val (hash_a))); + return result; +} + +nano::store_iterator nano::mdb_store::block_info_begin (nano::transaction const & transaction_a) +{ + nano::store_iterator result (std::make_unique> (transaction_a, blocks_info)); + return result; +} + +nano::store_iterator nano::mdb_store::block_info_end () +{ + nano::store_iterator result (nullptr); + return result; +} + +nano::store_iterator nano::mdb_store::representation_begin (nano::transaction const & transaction_a) +{ + nano::store_iterator result (std::make_unique> (transaction_a, representation)); + return result; +} + +nano::store_iterator nano::mdb_store::representation_end () +{ + nano::store_iterator result (nullptr); + return result; +} + +nano::store_iterator> nano::mdb_store::unchecked_begin (nano::transaction const & transaction_a) +{ + nano::store_iterator> result (std::make_unique>> (transaction_a, unchecked)); + return result; +} + +nano::store_iterator> nano::mdb_store::unchecked_begin (nano::transaction const & transaction_a, nano::unchecked_key const & key_a) +{ + nano::store_iterator> result (std::make_unique>> (transaction_a, unchecked, nano::mdb_val (key_a))); + return result; +} + +nano::store_iterator> nano::mdb_store::unchecked_end () +{ + nano::store_iterator> result (nullptr); + return result; +} + +nano::store_iterator> nano::mdb_store::vote_begin (nano::transaction const & transaction_a) +{ + return nano::store_iterator> (std::make_unique>> (transaction_a, vote)); +} + +nano::store_iterator> nano::mdb_store::vote_end () +{ + return nano::store_iterator> (nullptr); +} + +nano::mdb_store::mdb_store (bool & error_a, boost::filesystem::path const & path_a, int lmdb_max_dbs) : +env (error_a, path_a, lmdb_max_dbs), +frontiers (0), +accounts_v0 (0), +accounts_v1 (0), +send_blocks (0), +receive_blocks (0), +open_blocks (0), +change_blocks (0), +state_blocks_v0 (0), +state_blocks_v1 (0), +pending_v0 (0), +pending_v1 (0), +blocks_info (0), +representation (0), +unchecked (0), +checksum (0), +vote (0), +meta (0) +{ + if (!error_a) + { + auto transaction (tx_begin_write ()); + error_a |= mdb_dbi_open (env.tx (transaction), "frontiers", MDB_CREATE, &frontiers) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "accounts", MDB_CREATE, &accounts_v0) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "accounts_v1", MDB_CREATE, &accounts_v1) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "send", MDB_CREATE, &send_blocks) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "receive", MDB_CREATE, &receive_blocks) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "open", MDB_CREATE, &open_blocks) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "change", MDB_CREATE, &change_blocks) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "state", MDB_CREATE, &state_blocks_v0) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "state_v1", MDB_CREATE, &state_blocks_v1) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "pending", MDB_CREATE, &pending_v0) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "pending_v1", MDB_CREATE, &pending_v1) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "blocks_info", MDB_CREATE, &blocks_info) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "representation", MDB_CREATE, &representation) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "unchecked", MDB_CREATE, &unchecked) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "checksum", MDB_CREATE, &checksum) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "vote", MDB_CREATE, &vote) != 0; + error_a |= mdb_dbi_open (env.tx (transaction), "meta", MDB_CREATE, &meta) != 0; + if (!error_a) + { + do_upgrades (transaction); + checksum_put (transaction, 0, 0, 0); + } + } +} + +nano::transaction nano::mdb_store::tx_begin_write () +{ + return tx_begin (true); +} + +nano::transaction nano::mdb_store::tx_begin_read () +{ + return tx_begin (false); +} + +nano::transaction nano::mdb_store::tx_begin (bool write_a) +{ + return env.tx_begin (write_a); +} + +void nano::mdb_store::initialize (nano::transaction const & transaction_a, nano::genesis const & genesis_a) +{ + auto hash_l (genesis_a.hash ()); + assert (latest_v0_begin (transaction_a) == latest_v0_end ()); + assert (latest_v1_begin (transaction_a) == latest_v1_end ()); + block_put (transaction_a, hash_l, *genesis_a.open); + account_put (transaction_a, genesis_account, { hash_l, genesis_a.open->hash (), genesis_a.open->hash (), std::numeric_limits::max (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0 }); + representation_put (transaction_a, genesis_account, std::numeric_limits::max ()); + checksum_put (transaction_a, 0, 0, hash_l); + frontier_put (transaction_a, hash_l, genesis_account); +} + +void nano::mdb_store::version_put (nano::transaction const & transaction_a, int version_a) +{ + nano::uint256_union version_key (1); + nano::uint256_union version_value (version_a); + auto status (mdb_put (env.tx (transaction_a), meta, nano::mdb_val (version_key), nano::mdb_val (version_value), 0)); + release_assert (status == 0); +} + +int nano::mdb_store::version_get (nano::transaction const & transaction_a) +{ + nano::uint256_union version_key (1); + nano::mdb_val data; + auto error (mdb_get (env.tx (transaction_a), meta, nano::mdb_val (version_key), data)); + int result (1); + if (error != MDB_NOTFOUND) + { + nano::uint256_union version_value (data); + assert (version_value.qwords[2] == 0 && version_value.qwords[1] == 0 && version_value.qwords[0] == 0); + result = version_value.number ().convert_to (); + } + return result; +} + +nano::raw_key nano::mdb_store::get_node_id (nano::transaction const & transaction_a) +{ + nano::uint256_union node_id_mdb_key (3); + nano::raw_key node_id; + nano::mdb_val value; + auto error (mdb_get (env.tx (transaction_a), meta, nano::mdb_val (node_id_mdb_key), value)); + if (!error) + { + nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); + error = nano::read (stream, node_id.data); + assert (!error); + } + if (error) + { + nano::random_pool.GenerateBlock (node_id.data.bytes.data (), node_id.data.bytes.size ()); + error = mdb_put (env.tx (transaction_a), meta, nano::mdb_val (node_id_mdb_key), nano::mdb_val (node_id.data), 0); + } + assert (!error); + return node_id; +} + +void nano::mdb_store::delete_node_id (nano::transaction const & transaction_a) +{ + nano::uint256_union node_id_mdb_key (3); + auto error (mdb_del (env.tx (transaction_a), meta, nano::mdb_val (node_id_mdb_key), nullptr)); + assert (!error || error == MDB_NOTFOUND); +} + +void nano::mdb_store::do_upgrades (nano::transaction const & transaction_a) +{ + switch (version_get (transaction_a)) + { + case 1: + upgrade_v1_to_v2 (transaction_a); + case 2: + upgrade_v2_to_v3 (transaction_a); + case 3: + upgrade_v3_to_v4 (transaction_a); + case 4: + upgrade_v4_to_v5 (transaction_a); + case 5: + upgrade_v5_to_v6 (transaction_a); + case 6: + upgrade_v6_to_v7 (transaction_a); + case 7: + upgrade_v7_to_v8 (transaction_a); + case 8: + upgrade_v8_to_v9 (transaction_a); + case 9: + upgrade_v9_to_v10 (transaction_a); + case 10: + upgrade_v10_to_v11 (transaction_a); + case 11: + upgrade_v11_to_v12 (transaction_a); + case 12: + break; + default: + assert (false); + } +} + +void nano::mdb_store::upgrade_v1_to_v2 (nano::transaction const & transaction_a) +{ + version_put (transaction_a, 2); + nano::account account (1); + while (!account.is_zero ()) + { + nano::mdb_iterator i (transaction_a, accounts_v0, nano::mdb_val (account)); + std::cerr << std::hex; + if (i != nano::mdb_iterator (nullptr)) + { + account = nano::uint256_union (i->first); + nano::account_info_v1 v1 (i->second); + nano::account_info_v5 v2; + v2.balance = v1.balance; + v2.head = v1.head; + v2.modified = v1.modified; + v2.rep_block = v1.rep_block; + auto block (block_get (transaction_a, v1.head)); + while (!block->previous ().is_zero ()) + { + block = block_get (transaction_a, block->previous ()); + } + v2.open_block = block->hash (); + auto status (mdb_put (env.tx (transaction_a), accounts_v0, nano::mdb_val (account), v2.val (), 0)); + release_assert (status == 0); + account = account.number () + 1; + } + else + { + account.clear (); + } + } +} + +void nano::mdb_store::upgrade_v2_to_v3 (nano::transaction const & transaction_a) +{ + version_put (transaction_a, 3); + mdb_drop (env.tx (transaction_a), representation, 0); + for (auto i (std::make_unique> (transaction_a, accounts_v0)), n (std::make_unique> (nullptr)); *i != *n; ++(*i)) + { + nano::account account_l ((*i)->first); + nano::account_info_v5 info ((*i)->second); + representative_visitor visitor (transaction_a, *this); + visitor.compute (info.head); + assert (!visitor.result.is_zero ()); + info.rep_block = visitor.result; + auto impl (boost::polymorphic_downcast *> (i.get ())); + mdb_cursor_put (impl->cursor, nano::mdb_val (account_l), info.val (), MDB_CURRENT); + representation_add (transaction_a, visitor.result, info.balance.number ()); + } +} + +void nano::mdb_store::upgrade_v3_to_v4 (nano::transaction const & transaction_a) +{ + version_put (transaction_a, 4); + std::queue> items; + for (auto i (nano::store_iterator (std::make_unique> (transaction_a, pending_v0))), n (nano::store_iterator (nullptr)); i != n; ++i) + { + nano::block_hash hash (i->first); + nano::pending_info_v3 info (i->second); + items.push (std::make_pair (nano::pending_key (info.destination, hash), nano::pending_info (info.source, info.amount, nano::epoch::epoch_0))); + } + mdb_drop (env.tx (transaction_a), pending_v0, 0); + while (!items.empty ()) + { + pending_put (transaction_a, items.front ().first, items.front ().second); + items.pop (); + } +} + +void nano::mdb_store::upgrade_v4_to_v5 (nano::transaction const & transaction_a) +{ + version_put (transaction_a, 5); + for (auto i (nano::store_iterator (std::make_unique> (transaction_a, accounts_v0))), n (nano::store_iterator (nullptr)); i != n; ++i) + { + nano::account_info_v5 info (i->second); + nano::block_hash successor (0); + auto block (block_get (transaction_a, info.head)); + while (block != nullptr) + { + auto hash (block->hash ()); + if (block_successor (transaction_a, hash).is_zero () && !successor.is_zero ()) + { + block_put (transaction_a, hash, *block, successor); + } + successor = hash; + block = block_get (transaction_a, block->previous ()); + } + } +} + +void nano::mdb_store::upgrade_v5_to_v6 (nano::transaction const & transaction_a) +{ + version_put (transaction_a, 6); + std::deque> headers; + for (auto i (nano::store_iterator (std::make_unique> (transaction_a, accounts_v0))), n (nano::store_iterator (nullptr)); i != n; ++i) + { + nano::account account (i->first); + nano::account_info_v5 info_old (i->second); + uint64_t block_count (0); + auto hash (info_old.head); + while (!hash.is_zero ()) + { + ++block_count; + auto block (block_get (transaction_a, hash)); + assert (block != nullptr); + hash = block->previous (); + } + nano::account_info info (info_old.head, info_old.rep_block, info_old.open_block, info_old.balance, info_old.modified, block_count, nano::epoch::epoch_0); + headers.push_back (std::make_pair (account, info)); + } + for (auto i (headers.begin ()), n (headers.end ()); i != n; ++i) + { + account_put (transaction_a, i->first, i->second); + } +} + +void nano::mdb_store::upgrade_v6_to_v7 (nano::transaction const & transaction_a) +{ + version_put (transaction_a, 7); + mdb_drop (env.tx (transaction_a), unchecked, 0); +} + +void nano::mdb_store::upgrade_v7_to_v8 (nano::transaction const & transaction_a) +{ + version_put (transaction_a, 8); + mdb_drop (env.tx (transaction_a), unchecked, 1); + mdb_dbi_open (env.tx (transaction_a), "unchecked", MDB_CREATE | MDB_DUPSORT, &unchecked); +} + +void nano::mdb_store::upgrade_v8_to_v9 (nano::transaction const & transaction_a) +{ + version_put (transaction_a, 9); + MDB_dbi sequence; + mdb_dbi_open (env.tx (transaction_a), "sequence", MDB_CREATE | MDB_DUPSORT, &sequence); + nano::genesis genesis; + std::shared_ptr block (std::move (genesis.open)); + nano::keypair junk; + for (nano::mdb_iterator i (transaction_a, sequence), n (nano::mdb_iterator (nullptr)); i != n; ++i) + { + nano::bufferstream stream (reinterpret_cast (i->second.data ()), i->second.size ()); + uint64_t sequence; + auto error (nano::read (stream, sequence)); + // Create a dummy vote with the same sequence number for easy upgrading. This won't have a valid signature. + nano::vote dummy (nano::account (i->first), junk.prv, sequence, block); + std::vector vector; + { + nano::vectorstream stream (vector); + dummy.serialize (stream); + } + auto status1 (mdb_put (env.tx (transaction_a), vote, nano::mdb_val (i->first), nano::mdb_val (vector.size (), vector.data ()), 0)); + release_assert (status1 == 0); + assert (!error); + } + mdb_drop (env.tx (transaction_a), sequence, 1); +} + +void nano::mdb_store::upgrade_v9_to_v10 (nano::transaction const & transaction_a) +{ + //std::cerr << boost::str (boost::format ("Performing database upgrade to version 10...\n")); + version_put (transaction_a, 10); + for (auto i (latest_v0_begin (transaction_a)), n (latest_v0_end ()); i != n; ++i) + { + nano::account_info info (i->second); + if (info.block_count >= block_info_max) + { + nano::account account (i->first); + //std::cerr << boost::str (boost::format ("Upgrading account %1%...\n") % account.to_account ()); + size_t block_count (1); + auto hash (info.open_block); + while (!hash.is_zero ()) + { + if ((block_count % block_info_max) == 0) + { + nano::block_info block_info; + block_info.account = account; + nano::amount balance (block_balance (transaction_a, hash)); + block_info.balance = balance; + block_info_put (transaction_a, hash, block_info); + } + hash = block_successor (transaction_a, hash); + ++block_count; + } + } + } +} + +void nano::mdb_store::upgrade_v10_to_v11 (nano::transaction const & transaction_a) +{ + version_put (transaction_a, 11); + MDB_dbi unsynced; + mdb_dbi_open (env.tx (transaction_a), "unsynced", MDB_CREATE | MDB_DUPSORT, &unsynced); + mdb_drop (env.tx (transaction_a), unsynced, 1); +} + +void nano::mdb_store::upgrade_v11_to_v12 (nano::transaction const & transaction_a) +{ + version_put (transaction_a, 12); + mdb_drop (env.tx (transaction_a), unchecked, 1); + mdb_dbi_open (env.tx (transaction_a), "unchecked", MDB_CREATE, &unchecked); +} + +void nano::mdb_store::clear (MDB_dbi db_a) +{ + auto transaction (tx_begin_write ()); + auto status (mdb_drop (env.tx (transaction), db_a, 0)); + release_assert (status == 0); +} + +nano::uint128_t nano::mdb_store::block_balance (nano::transaction const & transaction_a, nano::block_hash const & hash_a) +{ + summation_visitor visitor (transaction_a, *this); + return visitor.compute_balance (hash_a); +} + +nano::epoch nano::mdb_store::block_version (nano::transaction const & transaction_a, nano::block_hash const & hash_a) +{ + nano::mdb_val value; + auto status (mdb_get (env.tx (transaction_a), state_blocks_v1, nano::mdb_val (hash_a), value)); + release_assert (status == 0 || status == MDB_NOTFOUND); + return status == 0 ? nano::epoch::epoch_1 : nano::epoch::epoch_0; +} + +void nano::mdb_store::representation_add (nano::transaction const & transaction_a, nano::block_hash const & source_a, nano::uint128_t const & amount_a) +{ + auto source_block (block_get (transaction_a, source_a)); + assert (source_block != nullptr); + auto source_rep (source_block->representative ()); + auto source_previous (representation_get (transaction_a, source_rep)); + representation_put (transaction_a, source_rep, source_previous + amount_a); +} + +MDB_dbi nano::mdb_store::block_database (nano::block_type type_a, nano::epoch epoch_a) +{ + if (type_a == nano::block_type::state) + { + assert (epoch_a == nano::epoch::epoch_0 || epoch_a == nano::epoch::epoch_1); + } + else + { + assert (epoch_a == nano::epoch::epoch_0); + } + MDB_dbi result; + switch (type_a) + { + case nano::block_type::send: + result = send_blocks; + break; + case nano::block_type::receive: + result = receive_blocks; + break; + case nano::block_type::open: + result = open_blocks; + break; + case nano::block_type::change: + result = change_blocks; + break; + case nano::block_type::state: + switch (epoch_a) + { + case nano::epoch::epoch_0: + result = state_blocks_v0; + break; + case nano::epoch::epoch_1: + result = state_blocks_v1; + break; + default: + assert (false); + } + break; + default: + assert (false); + break; + } + return result; +} + +void nano::mdb_store::block_raw_put (nano::transaction const & transaction_a, MDB_dbi database_a, nano::block_hash const & hash_a, MDB_val value_a) +{ + auto status2 (mdb_put (env.tx (transaction_a), database_a, nano::mdb_val (hash_a), &value_a, 0)); + release_assert (status2 == 0); +} + +void nano::mdb_store::block_put (nano::transaction const & transaction_a, nano::block_hash const & hash_a, nano::block const & block_a, nano::block_hash const & successor_a, nano::epoch epoch_a) +{ + assert (successor_a.is_zero () || block_exists (transaction_a, successor_a)); + std::vector vector; + { + nano::vectorstream stream (vector); + block_a.serialize (stream); + nano::write (stream, successor_a.bytes); + } + block_raw_put (transaction_a, block_database (block_a.type (), epoch_a), hash_a, { vector.size (), vector.data () }); + nano::block_predecessor_set predecessor (transaction_a, *this); + block_a.visit (predecessor); + assert (block_a.previous ().is_zero () || block_successor (transaction_a, block_a.previous ()) == hash_a); +} + +MDB_val nano::mdb_store::block_raw_get (nano::transaction const & transaction_a, nano::block_hash const & hash_a, nano::block_type & type_a) +{ + nano::mdb_val result; + auto status (mdb_get (env.tx (transaction_a), send_blocks, nano::mdb_val (hash_a), result)); + release_assert (status == 0 || status == MDB_NOTFOUND); + if (status != 0) + { + auto status (mdb_get (env.tx (transaction_a), receive_blocks, nano::mdb_val (hash_a), result)); + release_assert (status == 0 || status == MDB_NOTFOUND); + if (status != 0) + { + auto status (mdb_get (env.tx (transaction_a), open_blocks, nano::mdb_val (hash_a), result)); + release_assert (status == 0 || status == MDB_NOTFOUND); + if (status != 0) + { + auto status (mdb_get (env.tx (transaction_a), change_blocks, nano::mdb_val (hash_a), result)); + release_assert (status == 0 || status == MDB_NOTFOUND); + if (status != 0) + { + auto status (mdb_get (env.tx (transaction_a), state_blocks_v0, nano::mdb_val (hash_a), result)); + release_assert (status == 0 || status == MDB_NOTFOUND); + if (status != 0) + { + auto status (mdb_get (env.tx (transaction_a), state_blocks_v1, nano::mdb_val (hash_a), result)); + release_assert (status == 0 || status == MDB_NOTFOUND); + if (status != 0) + { + // Block not found + } + else + { + type_a = nano::block_type::state; + } + } + else + { + type_a = nano::block_type::state; + } + } + else + { + type_a = nano::block_type::change; + } + } + else + { + type_a = nano::block_type::open; + } + } + else + { + type_a = nano::block_type::receive; + } + } + else + { + type_a = nano::block_type::send; + } + return result; +} + +template +std::shared_ptr nano::mdb_store::block_random (nano::transaction const & transaction_a, MDB_dbi database) +{ + nano::block_hash hash; + nano::random_pool.GenerateBlock (hash.bytes.data (), hash.bytes.size ()); + nano::store_iterator> existing (std::make_unique>> (transaction_a, database, nano::mdb_val (hash))); + if (existing == nano::store_iterator> (nullptr)) + { + existing = nano::store_iterator> (std::make_unique>> (transaction_a, database)); + } + auto end (nano::store_iterator> (nullptr)); + assert (existing != end); + return block_get (transaction_a, nano::block_hash (existing->first)); +} + +std::shared_ptr nano::mdb_store::block_random (nano::transaction const & transaction_a) +{ + auto count (block_count (transaction_a)); + auto region (nano::random_pool.GenerateWord32 (0, count.sum () - 1)); + std::shared_ptr result; + if (region < count.send) + { + result = block_random (transaction_a, send_blocks); + } + else + { + region -= count.send; + if (region < count.receive) + { + result = block_random (transaction_a, receive_blocks); + } + else + { + region -= count.receive; + if (region < count.open) + { + result = block_random (transaction_a, open_blocks); + } + else + { + region -= count.open; + if (region < count.change) + { + result = block_random (transaction_a, change_blocks); + } + else + { + region -= count.change; + if (region < count.state_v0) + { + result = block_random (transaction_a, state_blocks_v0); + } + else + { + result = block_random (transaction_a, state_blocks_v1); + } + } + } + } + } + assert (result != nullptr); + return result; +} + +nano::block_hash nano::mdb_store::block_successor (nano::transaction const & transaction_a, nano::block_hash const & hash_a) +{ + nano::block_type type; + auto value (block_raw_get (transaction_a, hash_a, type)); + nano::block_hash result; + if (value.mv_size != 0) + { + assert (value.mv_size >= result.bytes.size ()); + nano::bufferstream stream (reinterpret_cast (value.mv_data) + value.mv_size - result.bytes.size (), result.bytes.size ()); + auto error (nano::read (stream, result.bytes)); + assert (!error); + } + else + { + result.clear (); + } + return result; +} + +void nano::mdb_store::block_successor_clear (nano::transaction const & transaction_a, nano::block_hash const & hash_a) +{ + auto block (block_get (transaction_a, hash_a)); + auto version (block_version (transaction_a, hash_a)); + block_put (transaction_a, hash_a, *block, 0, version); +} + +std::shared_ptr nano::mdb_store::block_get (nano::transaction const & transaction_a, nano::block_hash const & hash_a) +{ + nano::block_type type; + auto value (block_raw_get (transaction_a, hash_a, type)); + std::shared_ptr result; + if (value.mv_size != 0) + { + nano::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); + result = nano::deserialize_block (stream, type); + assert (result != nullptr); + } + return result; +} + +void nano::mdb_store::block_del (nano::transaction const & transaction_a, nano::block_hash const & hash_a) +{ + auto status (mdb_del (env.tx (transaction_a), state_blocks_v1, nano::mdb_val (hash_a), nullptr)); + release_assert (status == 0 || status == MDB_NOTFOUND); + if (status != 0) + { + auto status (mdb_del (env.tx (transaction_a), state_blocks_v0, nano::mdb_val (hash_a), nullptr)); + release_assert (status == 0 || status == MDB_NOTFOUND); + if (status != 0) + { + auto status (mdb_del (env.tx (transaction_a), send_blocks, nano::mdb_val (hash_a), nullptr)); + release_assert (status == 0 || status == MDB_NOTFOUND); + if (status != 0) + { + auto status (mdb_del (env.tx (transaction_a), receive_blocks, nano::mdb_val (hash_a), nullptr)); + release_assert (status == 0 || status == MDB_NOTFOUND); + if (status != 0) + { + auto status (mdb_del (env.tx (transaction_a), open_blocks, nano::mdb_val (hash_a), nullptr)); + release_assert (status == 0 || status == MDB_NOTFOUND); + if (status != 0) + { + auto status (mdb_del (env.tx (transaction_a), change_blocks, nano::mdb_val (hash_a), nullptr)); + release_assert (status == 0); + } + } + } + } + } +} + +bool nano::mdb_store::block_exists (nano::transaction const & transaction_a, nano::block_type type, nano::block_hash const & hash_a) +{ + auto exists (false); + nano::mdb_val junk; + + switch (type) + { + case nano::block_type::send: + { + auto status (mdb_get (env.tx (transaction_a), send_blocks, nano::mdb_val (hash_a), junk)); + assert (status == 0 || status == MDB_NOTFOUND); + exists = status == 0; + break; + } + case nano::block_type::receive: + { + auto status (mdb_get (env.tx (transaction_a), receive_blocks, nano::mdb_val (hash_a), junk)); + release_assert (status == 0 || status == MDB_NOTFOUND); + exists = status == 0; + break; + } + case nano::block_type::open: + { + auto status (mdb_get (env.tx (transaction_a), open_blocks, nano::mdb_val (hash_a), junk)); + release_assert (status == 0 || status == MDB_NOTFOUND); + exists = status == 0; + break; + } + case nano::block_type::change: + { + auto status (mdb_get (env.tx (transaction_a), change_blocks, nano::mdb_val (hash_a), junk)); + release_assert (status == 0 || status == MDB_NOTFOUND); + exists = status == 0; + break; + } + case nano::block_type::state: + { + auto status (mdb_get (env.tx (transaction_a), state_blocks_v0, nano::mdb_val (hash_a), junk)); + release_assert (status == 0 || status == MDB_NOTFOUND); + exists = status == 0; + if (!exists) + { + auto status (mdb_get (env.tx (transaction_a), state_blocks_v1, nano::mdb_val (hash_a), junk)); + release_assert (status == 0 || status == MDB_NOTFOUND); + exists = status == 0; + } + break; + } + case nano::block_type::invalid: + case nano::block_type::not_a_block: + break; + } + + return exists; +} + +bool nano::mdb_store::block_exists (nano::transaction const & tx_a, nano::block_hash const & hash_a) +{ + // clang-format off + return + block_exists (tx_a, nano::block_type::send, hash_a) || + block_exists (tx_a, nano::block_type::receive, hash_a) || + block_exists (tx_a, nano::block_type::open, hash_a) || + block_exists (tx_a, nano::block_type::change, hash_a) || + block_exists (tx_a, nano::block_type::state, hash_a); + // clang-format on +} + +nano::block_counts nano::mdb_store::block_count (nano::transaction const & transaction_a) +{ + nano::block_counts result; + MDB_stat send_stats; + auto status1 (mdb_stat (env.tx (transaction_a), send_blocks, &send_stats)); + release_assert (status1 == 0); + MDB_stat receive_stats; + auto status2 (mdb_stat (env.tx (transaction_a), receive_blocks, &receive_stats)); + release_assert (status2 == 0); + MDB_stat open_stats; + auto status3 (mdb_stat (env.tx (transaction_a), open_blocks, &open_stats)); + release_assert (status3 == 0); + MDB_stat change_stats; + auto status4 (mdb_stat (env.tx (transaction_a), change_blocks, &change_stats)); + release_assert (status4 == 0); + MDB_stat state_v0_stats; + auto status5 (mdb_stat (env.tx (transaction_a), state_blocks_v0, &state_v0_stats)); + release_assert (status5 == 0); + MDB_stat state_v1_stats; + auto status6 (mdb_stat (env.tx (transaction_a), state_blocks_v1, &state_v1_stats)); + release_assert (status6 == 0); + result.send = send_stats.ms_entries; + result.receive = receive_stats.ms_entries; + result.open = open_stats.ms_entries; + result.change = change_stats.ms_entries; + result.state_v0 = state_v0_stats.ms_entries; + result.state_v1 = state_v1_stats.ms_entries; + return result; +} + +bool nano::mdb_store::root_exists (nano::transaction const & transaction_a, nano::uint256_union const & root_a) +{ + return block_exists (transaction_a, root_a) || account_exists (transaction_a, root_a); +} + +void nano::mdb_store::account_del (nano::transaction const & transaction_a, nano::account const & account_a) +{ + auto status1 (mdb_del (env.tx (transaction_a), accounts_v1, nano::mdb_val (account_a), nullptr)); + if (status1 != 0) + { + release_assert (status1 == MDB_NOTFOUND); + auto status2 (mdb_del (env.tx (transaction_a), accounts_v0, nano::mdb_val (account_a), nullptr)); + release_assert (status2 == 0); + } +} + +bool nano::mdb_store::account_exists (nano::transaction const & transaction_a, nano::account const & account_a) +{ + auto iterator (latest_begin (transaction_a, account_a)); + return iterator != latest_end () && nano::account (iterator->first) == account_a; +} + +bool nano::mdb_store::account_get (nano::transaction const & transaction_a, nano::account const & account_a, nano::account_info & info_a) +{ + nano::mdb_val value; + auto status1 (mdb_get (env.tx (transaction_a), accounts_v1, nano::mdb_val (account_a), value)); + release_assert (status1 == 0 || status1 == MDB_NOTFOUND); + bool result (false); + nano::epoch epoch; + if (status1 == 0) + { + epoch = nano::epoch::epoch_1; + } + else + { + auto status2 (mdb_get (env.tx (transaction_a), accounts_v0, nano::mdb_val (account_a), value)); + release_assert (status2 == 0 || status2 == MDB_NOTFOUND); + if (status2 == 0) + { + epoch = nano::epoch::epoch_0; + } + else + { + result = true; + } + } + if (!result) + { + nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); + info_a.epoch = epoch; + info_a.deserialize (stream); + } + return result; +} + +void nano::mdb_store::frontier_put (nano::transaction const & transaction_a, nano::block_hash const & block_a, nano::account const & account_a) +{ + auto status (mdb_put (env.tx (transaction_a), frontiers, nano::mdb_val (block_a), nano::mdb_val (account_a), 0)); + release_assert (status == 0); +} + +nano::account nano::mdb_store::frontier_get (nano::transaction const & transaction_a, nano::block_hash const & block_a) +{ + nano::mdb_val value; + auto status (mdb_get (env.tx (transaction_a), frontiers, nano::mdb_val (block_a), value)); + release_assert (status == 0 || status == MDB_NOTFOUND); + nano::account result (0); + if (status == 0) + { + result = nano::uint256_union (value); + } + return result; +} + +void nano::mdb_store::frontier_del (nano::transaction const & transaction_a, nano::block_hash const & block_a) +{ + auto status (mdb_del (env.tx (transaction_a), frontiers, nano::mdb_val (block_a), nullptr)); + release_assert (status == 0); +} + +size_t nano::mdb_store::account_count (nano::transaction const & transaction_a) +{ + MDB_stat stats1; + auto status1 (mdb_stat (env.tx (transaction_a), accounts_v0, &stats1)); + release_assert (status1 == 0); + MDB_stat stats2; + auto status2 (mdb_stat (env.tx (transaction_a), accounts_v1, &stats2)); + release_assert (status2 == 0); + auto result (stats1.ms_entries + stats2.ms_entries); + return result; +} + +void nano::mdb_store::account_put (nano::transaction const & transaction_a, nano::account const & account_a, nano::account_info const & info_a) +{ + MDB_dbi db; + switch (info_a.epoch) + { + case nano::epoch::invalid: + case nano::epoch::unspecified: + assert (false); + case nano::epoch::epoch_0: + db = accounts_v0; + break; + case nano::epoch::epoch_1: + db = accounts_v1; + break; + } + auto status (mdb_put (env.tx (transaction_a), db, nano::mdb_val (account_a), nano::mdb_val (info_a), 0)); + release_assert (status == 0); +} + +void nano::mdb_store::pending_put (nano::transaction const & transaction_a, nano::pending_key const & key_a, nano::pending_info const & pending_a) +{ + MDB_dbi db; + switch (pending_a.epoch) + { + case nano::epoch::invalid: + case nano::epoch::unspecified: + assert (false); + case nano::epoch::epoch_0: + db = pending_v0; + break; + case nano::epoch::epoch_1: + db = pending_v1; + break; + } + auto status (mdb_put (env.tx (transaction_a), db, nano::mdb_val (key_a), nano::mdb_val (pending_a), 0)); + release_assert (status == 0); +} + +void nano::mdb_store::pending_del (nano::transaction const & transaction_a, nano::pending_key const & key_a) +{ + auto status1 (mdb_del (env.tx (transaction_a), pending_v1, mdb_val (key_a), nullptr)); + if (status1 != 0) + { + release_assert (status1 == MDB_NOTFOUND); + auto status2 (mdb_del (env.tx (transaction_a), pending_v0, mdb_val (key_a), nullptr)); + release_assert (status2 == 0); + } +} + +bool nano::mdb_store::pending_exists (nano::transaction const & transaction_a, nano::pending_key const & key_a) +{ + auto iterator (pending_begin (transaction_a, key_a)); + return iterator != pending_end () && nano::pending_key (iterator->first) == key_a; +} + +bool nano::mdb_store::pending_get (nano::transaction const & transaction_a, nano::pending_key const & key_a, nano::pending_info & pending_a) +{ + nano::mdb_val value; + auto status1 (mdb_get (env.tx (transaction_a), pending_v1, mdb_val (key_a), value)); + release_assert (status1 == 0 || status1 == MDB_NOTFOUND); + bool result (false); + nano::epoch epoch; + if (status1 == 0) + { + epoch = nano::epoch::epoch_1; + } + else + { + auto status2 (mdb_get (env.tx (transaction_a), pending_v0, mdb_val (key_a), value)); + release_assert (status2 == 0 || status2 == MDB_NOTFOUND); + if (status2 == 0) + { + epoch = nano::epoch::epoch_0; + } + else + { + result = true; + } + } + if (!result) + { + nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); + pending_a.epoch = epoch; + pending_a.deserialize (stream); + } + return result; +} + +nano::store_iterator nano::mdb_store::pending_begin (nano::transaction const & transaction_a, nano::pending_key const & key_a) +{ + nano::store_iterator result (std::make_unique> (transaction_a, pending_v0, pending_v1, mdb_val (key_a))); + return result; +} + +nano::store_iterator nano::mdb_store::pending_begin (nano::transaction const & transaction_a) +{ + nano::store_iterator result (std::make_unique> (transaction_a, pending_v0, pending_v1)); + return result; +} + +nano::store_iterator nano::mdb_store::pending_end () +{ + nano::store_iterator result (nullptr); + return result; +} + +nano::store_iterator nano::mdb_store::pending_v0_begin (nano::transaction const & transaction_a, nano::pending_key const & key_a) +{ + nano::store_iterator result (std::make_unique> (transaction_a, pending_v0, mdb_val (key_a))); + return result; +} + +nano::store_iterator nano::mdb_store::pending_v0_begin (nano::transaction const & transaction_a) +{ + nano::store_iterator result (std::make_unique> (transaction_a, pending_v0)); + return result; +} + +nano::store_iterator nano::mdb_store::pending_v0_end () +{ + nano::store_iterator result (nullptr); + return result; +} + +nano::store_iterator nano::mdb_store::pending_v1_begin (nano::transaction const & transaction_a, nano::pending_key const & key_a) +{ + nano::store_iterator result (std::make_unique> (transaction_a, pending_v1, mdb_val (key_a))); + return result; +} + +nano::store_iterator nano::mdb_store::pending_v1_begin (nano::transaction const & transaction_a) +{ + nano::store_iterator result (std::make_unique> (transaction_a, pending_v1)); + return result; +} + +nano::store_iterator nano::mdb_store::pending_v1_end () +{ + nano::store_iterator result (nullptr); + return result; +} + +void nano::mdb_store::block_info_put (nano::transaction const & transaction_a, nano::block_hash const & hash_a, nano::block_info const & block_info_a) +{ + auto status (mdb_put (env.tx (transaction_a), blocks_info, nano::mdb_val (hash_a), nano::mdb_val (block_info_a), 0)); + release_assert (status == 0); +} + +void nano::mdb_store::block_info_del (nano::transaction const & transaction_a, nano::block_hash const & hash_a) +{ + auto status (mdb_del (env.tx (transaction_a), blocks_info, nano::mdb_val (hash_a), nullptr)); + release_assert (status == 0); +} + +bool nano::mdb_store::block_info_exists (nano::transaction const & transaction_a, nano::block_hash const & hash_a) +{ + auto iterator (block_info_begin (transaction_a, hash_a)); + return iterator != block_info_end () && nano::block_hash (iterator->first) == hash_a; +} + +bool nano::mdb_store::block_info_get (nano::transaction const & transaction_a, nano::block_hash const & hash_a, nano::block_info & block_info_a) +{ + nano::mdb_val value; + auto status (mdb_get (env.tx (transaction_a), blocks_info, nano::mdb_val (hash_a), value)); + release_assert (status == 0 || status == MDB_NOTFOUND); + bool result (true); + if (status != MDB_NOTFOUND) + { + result = false; + assert (value.size () == sizeof (block_info_a.account.bytes) + sizeof (block_info_a.balance.bytes)); + nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); + auto error1 (nano::read (stream, block_info_a.account)); + assert (!error1); + auto error2 (nano::read (stream, block_info_a.balance)); + assert (!error2); + } + return result; +} + +nano::uint128_t nano::mdb_store::representation_get (nano::transaction const & transaction_a, nano::account const & account_a) +{ + nano::mdb_val value; + auto status (mdb_get (env.tx (transaction_a), representation, nano::mdb_val (account_a), value)); + release_assert (status == 0 || status == MDB_NOTFOUND); + nano::uint128_t result = 0; + if (status == 0) + { + nano::uint128_union rep; + nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); + auto error (nano::read (stream, rep)); + assert (!error); + result = rep.number (); + } + return result; +} + +void nano::mdb_store::representation_put (nano::transaction const & transaction_a, nano::account const & account_a, nano::uint128_t const & representation_a) +{ + nano::uint128_union rep (representation_a); + auto status (mdb_put (env.tx (transaction_a), representation, nano::mdb_val (account_a), nano::mdb_val (rep), 0)); + release_assert (status == 0); +} + +void nano::mdb_store::unchecked_clear (nano::transaction const & transaction_a) +{ + auto status (mdb_drop (env.tx (transaction_a), unchecked, 0)); + release_assert (status == 0); +} + +void nano::mdb_store::unchecked_put (nano::transaction const & transaction_a, nano::unchecked_key const & key_a, std::shared_ptr const & block_a) +{ + mdb_val block (block_a); + auto status (mdb_put (env.tx (transaction_a), unchecked, nano::mdb_val (key_a), block, 0)); + release_assert (status == 0); +} + +void nano::mdb_store::unchecked_put (nano::transaction const & transaction_a, nano::block_hash const & hash_a, std::shared_ptr const & block_a) +{ + nano::unchecked_key key (hash_a, block_a->hash ()); + unchecked_put (transaction_a, key, block_a); +} + +std::shared_ptr nano::mdb_store::vote_get (nano::transaction const & transaction_a, nano::account const & account_a) +{ + nano::mdb_val value; + auto status (mdb_get (env.tx (transaction_a), vote, nano::mdb_val (account_a), value)); + release_assert (status == 0 || status == MDB_NOTFOUND); + if (status == 0) + { + std::shared_ptr result (value); + assert (result != nullptr); + return result; + } + return nullptr; +} + +std::vector> nano::mdb_store::unchecked_get (nano::transaction const & transaction_a, nano::block_hash const & hash_a) +{ + std::vector> result; + for (auto i (unchecked_begin (transaction_a, nano::unchecked_key (hash_a, 0))), n (unchecked_end ()); i != n && nano::block_hash (i->first.key ()) == hash_a; ++i) + { + std::shared_ptr block (i->second); + result.push_back (block); + } + return result; +} + +bool nano::mdb_store::unchecked_exists (nano::transaction const & transaction_a, nano::unchecked_key const & key_a) +{ + auto iterator (unchecked_begin (transaction_a, key_a)); + return iterator != unchecked_end () && nano::unchecked_key (iterator->first) == key_a; +} + +void nano::mdb_store::unchecked_del (nano::transaction const & transaction_a, nano::unchecked_key const & key_a) +{ + auto status (mdb_del (env.tx (transaction_a), unchecked, nano::mdb_val (key_a), nullptr)); + release_assert (status == 0 || status == MDB_NOTFOUND); +} + +size_t nano::mdb_store::unchecked_count (nano::transaction const & transaction_a) +{ + MDB_stat unchecked_stats; + auto status (mdb_stat (env.tx (transaction_a), unchecked, &unchecked_stats)); + release_assert (status == 0); + auto result (unchecked_stats.ms_entries); + return result; +} + +void nano::mdb_store::checksum_put (nano::transaction const & transaction_a, uint64_t prefix, uint8_t mask, nano::uint256_union const & hash_a) +{ + assert ((prefix & 0xff) == 0); + uint64_t key (prefix | mask); + auto status (mdb_put (env.tx (transaction_a), checksum, nano::mdb_val (sizeof (key), &key), nano::mdb_val (hash_a), 0)); + release_assert (status == 0); +} + +bool nano::mdb_store::checksum_get (nano::transaction const & transaction_a, uint64_t prefix, uint8_t mask, nano::uint256_union & hash_a) +{ + assert ((prefix & 0xff) == 0); + uint64_t key (prefix | mask); + nano::mdb_val value; + auto status (mdb_get (env.tx (transaction_a), checksum, nano::mdb_val (sizeof (key), &key), value)); + release_assert (status == 0 || status == MDB_NOTFOUND); + bool result (true); + if (status == 0) + { + result = false; + nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); + auto error (nano::read (stream, hash_a)); + assert (!error); + } + return result; +} + +void nano::mdb_store::checksum_del (nano::transaction const & transaction_a, uint64_t prefix, uint8_t mask) +{ + assert ((prefix & 0xff) == 0); + uint64_t key (prefix | mask); + auto status (mdb_del (env.tx (transaction_a), checksum, nano::mdb_val (sizeof (key), &key), nullptr)); + release_assert (status == 0); +} + +void nano::mdb_store::flush (nano::transaction const & transaction_a) +{ + { + std::lock_guard lock (cache_mutex); + vote_cache_l1.swap (vote_cache_l2); + vote_cache_l1.clear (); + } + for (auto i (vote_cache_l2.begin ()), n (vote_cache_l2.end ()); i != n; ++i) + { + std::vector vector; + { + nano::vectorstream stream (vector); + i->second->serialize (stream); + } + auto status1 (mdb_put (env.tx (transaction_a), vote, nano::mdb_val (i->first), nano::mdb_val (vector.size (), vector.data ()), 0)); + release_assert (status1 == 0); + } +} +std::shared_ptr nano::mdb_store::vote_current (nano::transaction const & transaction_a, nano::account const & account_a) +{ + assert (!cache_mutex.try_lock ()); + std::shared_ptr result; + auto existing (vote_cache_l1.find (account_a)); + auto have_existing (true); + if (existing == vote_cache_l1.end ()) + { + existing = vote_cache_l2.find (account_a); + if (existing == vote_cache_l2.end ()) + { + have_existing = false; + } + } + if (have_existing) + { + result = existing->second; + } + else + { + result = vote_get (transaction_a, account_a); + } + return result; +} + +std::shared_ptr nano::mdb_store::vote_generate (nano::transaction const & transaction_a, nano::account const & account_a, nano::raw_key const & key_a, std::shared_ptr block_a) +{ + std::lock_guard lock (cache_mutex); + auto result (vote_current (transaction_a, account_a)); + uint64_t sequence ((result ? result->sequence : 0) + 1); + result = std::make_shared (account_a, key_a, sequence, block_a); + vote_cache_l1[account_a] = result; + return result; +} + +std::shared_ptr nano::mdb_store::vote_generate (nano::transaction const & transaction_a, nano::account const & account_a, nano::raw_key const & key_a, std::vector blocks_a) +{ + std::lock_guard lock (cache_mutex); + auto result (vote_current (transaction_a, account_a)); + uint64_t sequence ((result ? result->sequence : 0) + 1); + result = std::make_shared (account_a, key_a, sequence, blocks_a); + vote_cache_l1[account_a] = result; + return result; +} + +std::shared_ptr nano::mdb_store::vote_max (nano::transaction const & transaction_a, std::shared_ptr vote_a) +{ + std::lock_guard lock (cache_mutex); + auto current (vote_current (transaction_a, vote_a->account)); + auto result (vote_a); + if (current != nullptr && current->sequence > result->sequence) + { + result = current; + } + vote_cache_l1[vote_a->account] = result; + return result; +} + +nano::store_iterator nano::mdb_store::latest_begin (nano::transaction const & transaction_a, nano::account const & account_a) +{ + nano::store_iterator result (std::make_unique> (transaction_a, accounts_v0, accounts_v1, nano::mdb_val (account_a))); + return result; +} + +nano::store_iterator nano::mdb_store::latest_begin (nano::transaction const & transaction_a) +{ + nano::store_iterator result (std::make_unique> (transaction_a, accounts_v0, accounts_v1)); + return result; +} + +nano::store_iterator nano::mdb_store::latest_end () +{ + nano::store_iterator result (nullptr); + return result; +} + +nano::store_iterator nano::mdb_store::latest_v0_begin (nano::transaction const & transaction_a, nano::account const & account_a) +{ + nano::store_iterator result (std::make_unique> (transaction_a, accounts_v0, nano::mdb_val (account_a))); + return result; +} + +nano::store_iterator nano::mdb_store::latest_v0_begin (nano::transaction const & transaction_a) +{ + nano::store_iterator result (std::make_unique> (transaction_a, accounts_v0)); + return result; +} + +nano::store_iterator nano::mdb_store::latest_v0_end () +{ + nano::store_iterator result (nullptr); + return result; +} + +nano::store_iterator nano::mdb_store::latest_v1_begin (nano::transaction const & transaction_a, nano::account const & account_a) +{ + nano::store_iterator result (std::make_unique> (transaction_a, accounts_v1, nano::mdb_val (account_a))); + return result; +} + +nano::store_iterator nano::mdb_store::latest_v1_begin (nano::transaction const & transaction_a) +{ + nano::store_iterator result (std::make_unique> (transaction_a, accounts_v1)); + return result; +} + +nano::store_iterator nano::mdb_store::latest_v1_end () +{ + nano::store_iterator result (nullptr); + return result; +} diff --git a/nano/node/lmdb.hpp b/nano/node/lmdb.hpp new file mode 100644 index 00000000..dfc3da3b --- /dev/null +++ b/nano/node/lmdb.hpp @@ -0,0 +1,389 @@ +#pragma once + +#include + +#include + +#include +#include +#include + +namespace nano +{ +class mdb_env; +class mdb_txn : public transaction_impl +{ +public: + mdb_txn (nano::mdb_env const &, bool = false); + mdb_txn (nano::mdb_txn const &) = delete; + mdb_txn (nano::mdb_txn &&) = default; + ~mdb_txn (); + nano::mdb_txn & operator= (nano::mdb_txn const &) = delete; + nano::mdb_txn & operator= (nano::mdb_txn &&) = default; + operator MDB_txn * () const; + MDB_txn * handle; +}; +/** + * RAII wrapper for MDB_env + */ +class mdb_env +{ +public: + mdb_env (bool &, boost::filesystem::path const &, int max_dbs = 128); + ~mdb_env (); + operator MDB_env * () const; + nano::transaction tx_begin (bool = false) const; + MDB_txn * tx (nano::transaction const &) const; + MDB_env * environment; +}; + +/** + * Encapsulates MDB_val and provides uint256_union conversion of the data. + */ +class mdb_val +{ +public: + enum class no_value + { + dummy + }; + mdb_val (nano::epoch = nano::epoch::unspecified); + mdb_val (nano::account_info const &); + mdb_val (nano::block_info const &); + mdb_val (MDB_val const &, nano::epoch = nano::epoch::unspecified); + mdb_val (nano::pending_info const &); + mdb_val (nano::pending_key const &); + mdb_val (size_t, void *); + mdb_val (nano::uint128_union const &); + mdb_val (nano::uint256_union const &); + mdb_val (std::shared_ptr const &); + mdb_val (std::shared_ptr const &); + void * data () const; + size_t size () const; + explicit operator nano::account_info () const; + explicit operator nano::block_info () const; + explicit operator nano::pending_info () const; + explicit operator nano::pending_key () const; + explicit operator nano::uint128_union () const; + explicit operator nano::uint256_union () const; + explicit operator std::array () const; + explicit operator no_value () const; + explicit operator std::shared_ptr () const; + explicit operator std::shared_ptr () const; + explicit operator std::shared_ptr () const; + explicit operator std::shared_ptr () const; + explicit operator std::shared_ptr () const; + explicit operator std::shared_ptr () const; + explicit operator std::shared_ptr () const; + explicit operator uint64_t () const; + operator MDB_val * () const; + operator MDB_val const & () const; + MDB_val value; + std::shared_ptr> buffer; + nano::epoch epoch{ nano::epoch::unspecified }; +}; +class block_store; + +template +class mdb_iterator : public store_iterator_impl +{ +public: + mdb_iterator (nano::transaction const & transaction_a, MDB_dbi db_a, nano::epoch = nano::epoch::unspecified); + mdb_iterator (std::nullptr_t, nano::epoch = nano::epoch::unspecified); + mdb_iterator (nano::transaction const & transaction_a, MDB_dbi db_a, MDB_val const & val_a, nano::epoch = nano::epoch::unspecified); + mdb_iterator (nano::mdb_iterator && other_a); + mdb_iterator (nano::mdb_iterator const &) = delete; + ~mdb_iterator (); + nano::store_iterator_impl & operator++ () override; + std::pair * operator-> (); + bool operator== (nano::store_iterator_impl const & other_a) const override; + bool is_end_sentinal () const override; + void fill (std::pair &) const override; + void clear (); + nano::mdb_iterator & operator= (nano::mdb_iterator && other_a); + nano::store_iterator_impl & operator= (nano::store_iterator_impl const &) = delete; + MDB_cursor * cursor; + std::pair current; + +private: + MDB_txn * tx (nano::transaction const &) const; +}; + +/** + * Iterates the key/value pairs of two stores merged together + */ +template +class mdb_merge_iterator : public store_iterator_impl +{ +public: + mdb_merge_iterator (nano::transaction const &, MDB_dbi, MDB_dbi); + mdb_merge_iterator (std::nullptr_t); + mdb_merge_iterator (nano::transaction const &, MDB_dbi, MDB_dbi, MDB_val const &); + mdb_merge_iterator (nano::mdb_merge_iterator &&); + mdb_merge_iterator (nano::mdb_merge_iterator const &) = delete; + ~mdb_merge_iterator (); + nano::store_iterator_impl & operator++ () override; + std::pair * operator-> (); + bool operator== (nano::store_iterator_impl const &) const override; + bool is_end_sentinal () const override; + void fill (std::pair &) const override; + void clear (); + nano::mdb_merge_iterator & operator= (nano::mdb_merge_iterator &&) = default; + nano::mdb_merge_iterator & operator= (nano::mdb_merge_iterator const &) = delete; + +private: + nano::mdb_iterator & least_iterator () const; + std::unique_ptr> impl1; + std::unique_ptr> impl2; +}; + +/** + * mdb implementation of the block store + */ +class mdb_store : public block_store +{ + friend class nano::block_predecessor_set; + +public: + mdb_store (bool &, boost::filesystem::path const &, int lmdb_max_dbs = 128); + + nano::transaction tx_begin_write () override; + nano::transaction tx_begin_read () override; + nano::transaction tx_begin (bool write = false) override; + + void initialize (nano::transaction const &, nano::genesis const &) override; + void block_put (nano::transaction const &, nano::block_hash const &, nano::block const &, nano::block_hash const & = nano::block_hash (0), nano::epoch version = nano::epoch::epoch_0) override; + nano::block_hash block_successor (nano::transaction const &, nano::block_hash const &) override; + void block_successor_clear (nano::transaction const &, nano::block_hash const &) override; + std::shared_ptr block_get (nano::transaction const &, nano::block_hash const &) override; + std::shared_ptr block_random (nano::transaction const &) override; + void block_del (nano::transaction const &, nano::block_hash const &) override; + bool block_exists (nano::transaction const &, nano::block_hash const &) override; + bool block_exists (nano::transaction const &, nano::block_type, nano::block_hash const &) override; + nano::block_counts block_count (nano::transaction const &) override; + bool root_exists (nano::transaction const &, nano::uint256_union const &) override; + + void frontier_put (nano::transaction const &, nano::block_hash const &, nano::account const &) override; + nano::account frontier_get (nano::transaction const &, nano::block_hash const &) override; + void frontier_del (nano::transaction const &, nano::block_hash const &) override; + + void account_put (nano::transaction const &, nano::account const &, nano::account_info const &) override; + bool account_get (nano::transaction const &, nano::account const &, nano::account_info &) override; + void account_del (nano::transaction const &, nano::account const &) override; + bool account_exists (nano::transaction const &, nano::account const &) override; + size_t account_count (nano::transaction const &) override; + nano::store_iterator latest_v0_begin (nano::transaction const &, nano::account const &) override; + nano::store_iterator latest_v0_begin (nano::transaction const &) override; + nano::store_iterator latest_v0_end () override; + nano::store_iterator latest_v1_begin (nano::transaction const &, nano::account const &) override; + nano::store_iterator latest_v1_begin (nano::transaction const &) override; + nano::store_iterator latest_v1_end () override; + nano::store_iterator latest_begin (nano::transaction const &, nano::account const &) override; + nano::store_iterator latest_begin (nano::transaction const &) override; + nano::store_iterator latest_end () override; + + void pending_put (nano::transaction const &, nano::pending_key const &, nano::pending_info const &) override; + void pending_del (nano::transaction const &, nano::pending_key const &) override; + bool pending_get (nano::transaction const &, nano::pending_key const &, nano::pending_info &) override; + bool pending_exists (nano::transaction const &, nano::pending_key const &) override; + nano::store_iterator pending_v0_begin (nano::transaction const &, nano::pending_key const &) override; + nano::store_iterator pending_v0_begin (nano::transaction const &) override; + nano::store_iterator pending_v0_end () override; + nano::store_iterator pending_v1_begin (nano::transaction const &, nano::pending_key const &) override; + nano::store_iterator pending_v1_begin (nano::transaction const &) override; + nano::store_iterator pending_v1_end () override; + nano::store_iterator pending_begin (nano::transaction const &, nano::pending_key const &) override; + nano::store_iterator pending_begin (nano::transaction const &) override; + nano::store_iterator pending_end () override; + + void block_info_put (nano::transaction const &, nano::block_hash const &, nano::block_info const &) override; + void block_info_del (nano::transaction const &, nano::block_hash const &) override; + bool block_info_get (nano::transaction const &, nano::block_hash const &, nano::block_info &) override; + bool block_info_exists (nano::transaction const &, nano::block_hash const &) override; + nano::store_iterator block_info_begin (nano::transaction const &, nano::block_hash const &) override; + nano::store_iterator block_info_begin (nano::transaction const &) override; + nano::store_iterator block_info_end () override; + nano::uint128_t block_balance (nano::transaction const &, nano::block_hash const &) override; + nano::epoch block_version (nano::transaction const &, nano::block_hash const &) override; + + nano::uint128_t representation_get (nano::transaction const &, nano::account const &) override; + void representation_put (nano::transaction const &, nano::account const &, nano::uint128_t const &) override; + void representation_add (nano::transaction const &, nano::account const &, nano::uint128_t const &) override; + nano::store_iterator representation_begin (nano::transaction const &) override; + nano::store_iterator representation_end () override; + + void unchecked_clear (nano::transaction const &) override; + void unchecked_put (nano::transaction const &, nano::unchecked_key const &, std::shared_ptr const &) override; + void unchecked_put (nano::transaction const &, nano::block_hash const &, std::shared_ptr const &) override; + std::vector> unchecked_get (nano::transaction const &, nano::block_hash const &) override; + bool unchecked_exists (nano::transaction const &, nano::unchecked_key const &) override; + void unchecked_del (nano::transaction const &, nano::unchecked_key const &) override; + nano::store_iterator> unchecked_begin (nano::transaction const &) override; + nano::store_iterator> unchecked_begin (nano::transaction const &, nano::unchecked_key const &) override; + nano::store_iterator> unchecked_end () override; + size_t unchecked_count (nano::transaction const &) override; + + void checksum_put (nano::transaction const &, uint64_t, uint8_t, nano::checksum const &) override; + bool checksum_get (nano::transaction const &, uint64_t, uint8_t, nano::checksum &) override; + void checksum_del (nano::transaction const &, uint64_t, uint8_t) override; + + // Return latest vote for an account from store + std::shared_ptr vote_get (nano::transaction const &, nano::account const &) override; + // Populate vote with the next sequence number + std::shared_ptr vote_generate (nano::transaction const &, nano::account const &, nano::raw_key const &, std::shared_ptr) override; + std::shared_ptr vote_generate (nano::transaction const &, nano::account const &, nano::raw_key const &, std::vector) override; + // Return either vote or the stored vote with a higher sequence number + std::shared_ptr vote_max (nano::transaction const &, std::shared_ptr) override; + // Return latest vote for an account considering the vote cache + std::shared_ptr vote_current (nano::transaction const &, nano::account const &) override; + void flush (nano::transaction const &) override; + nano::store_iterator> vote_begin (nano::transaction const &) override; + nano::store_iterator> vote_end () override; + std::mutex cache_mutex; + std::unordered_map> vote_cache_l1; + std::unordered_map> vote_cache_l2; + + void version_put (nano::transaction const &, int) override; + int version_get (nano::transaction const &) override; + void do_upgrades (nano::transaction const &); + void upgrade_v1_to_v2 (nano::transaction const &); + void upgrade_v2_to_v3 (nano::transaction const &); + void upgrade_v3_to_v4 (nano::transaction const &); + void upgrade_v4_to_v5 (nano::transaction const &); + void upgrade_v5_to_v6 (nano::transaction const &); + void upgrade_v6_to_v7 (nano::transaction const &); + void upgrade_v7_to_v8 (nano::transaction const &); + void upgrade_v8_to_v9 (nano::transaction const &); + void upgrade_v9_to_v10 (nano::transaction const &); + void upgrade_v10_to_v11 (nano::transaction const &); + void upgrade_v11_to_v12 (nano::transaction const &); + + // Requires a write transaction + nano::raw_key get_node_id (nano::transaction const &) override; + + /** Deletes the node ID from the store */ + void delete_node_id (nano::transaction const &) override; + + nano::mdb_env env; + + /** + * Maps head block to owning account + * nano::block_hash -> nano::account + */ + MDB_dbi frontiers; + + /** + * Maps account v1 to account information, head, rep, open, balance, timestamp and block count. + * nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t + */ + MDB_dbi accounts_v0; + + /** + * Maps account v0 to account information, head, rep, open, balance, timestamp and block count. + * nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t + */ + MDB_dbi accounts_v1; + + /** + * Maps block hash to send block. + * nano::block_hash -> nano::send_block + */ + MDB_dbi send_blocks; + + /** + * Maps block hash to receive block. + * nano::block_hash -> nano::receive_block + */ + MDB_dbi receive_blocks; + + /** + * Maps block hash to open block. + * nano::block_hash -> nano::open_block + */ + MDB_dbi open_blocks; + + /** + * Maps block hash to change block. + * nano::block_hash -> nano::change_block + */ + MDB_dbi change_blocks; + + /** + * Maps block hash to v0 state block. + * nano::block_hash -> nano::state_block + */ + MDB_dbi state_blocks_v0; + + /** + * Maps block hash to v1 state block. + * nano::block_hash -> nano::state_block + */ + MDB_dbi state_blocks_v1; + + /** + * Maps min_version 0 (destination account, pending block) to (source account, amount). + * nano::account, nano::block_hash -> nano::account, nano::amount + */ + MDB_dbi pending_v0; + + /** + * Maps min_version 1 (destination account, pending block) to (source account, amount). + * nano::account, nano::block_hash -> nano::account, nano::amount + */ + MDB_dbi pending_v1; + + /** + * Maps block hash to account and balance. + * block_hash -> nano::account, nano::amount + */ + MDB_dbi blocks_info; + + /** + * Representative weights. + * nano::account -> nano::uint128_t + */ + MDB_dbi representation; + + /** + * Unchecked bootstrap blocks. + * nano::block_hash -> nano::block + */ + MDB_dbi unchecked; + + /** + * Mapping of region to checksum. + * (uint56_t, uint8_t) -> nano::block_hash + */ + MDB_dbi checksum; + + /** + * Highest vote observed for account. + * nano::account -> uint64_t + */ + MDB_dbi vote; + + /** + * Meta information about block store, such as versions. + * nano::uint256_union (arbitrary key) -> blob + */ + MDB_dbi meta; + +private: + MDB_dbi block_database (nano::block_type, nano::epoch); + template + std::shared_ptr block_random (nano::transaction const &, MDB_dbi); + MDB_val block_raw_get (nano::transaction const &, nano::block_hash const &, nano::block_type &); + void block_raw_put (nano::transaction const &, MDB_dbi, nano::block_hash const &, MDB_val); + void clear (MDB_dbi); +}; +class wallet_value +{ +public: + wallet_value () = default; + wallet_value (nano::mdb_val const &); + wallet_value (nano::uint256_union const &, uint64_t); + nano::mdb_val val () const; + nano::private_key key; + uint64_t work; +}; +} diff --git a/rai/node/logging.cpp b/nano/node/logging.cpp similarity index 82% rename from rai/node/logging.cpp rename to nano/node/logging.cpp index ecca95b3..00e1bf4c 100644 --- a/rai/node/logging.cpp +++ b/nano/node/logging.cpp @@ -2,9 +2,9 @@ #include #include #include -#include +#include -rai::logging::logging () : +nano::logging::logging () : ledger_logging_value (false), ledger_duplicate_logging_value (false), vote_logging_value (false), @@ -28,7 +28,7 @@ rotation_size (4 * 1024 * 1024) { } -void rai::logging::init (boost::filesystem::path const & application_path_a) +void nano::logging::init (boost::filesystem::path const & application_path_a) { static std::atomic_flag logging_already_added = ATOMIC_FLAG_INIT; if (!logging_already_added.test_and_set ()) @@ -42,7 +42,7 @@ void rai::logging::init (boost::filesystem::path const & application_path_a) } } -void rai::logging::serialize_json (boost::property_tree::ptree & tree_a) const +void nano::logging::serialize_json (boost::property_tree::ptree & tree_a) const { tree_a.put ("version", std::to_string (json_version)); tree_a.put ("ledger", ledger_logging_value); @@ -67,7 +67,7 @@ void rai::logging::serialize_json (boost::property_tree::ptree & tree_a) const tree_a.put ("flush", flush); } -bool rai::logging::upgrade_json (unsigned version_a, boost::property_tree::ptree & tree_a) +bool nano::logging::upgrade_json (unsigned version_a, boost::property_tree::ptree & tree_a) { tree_a.put ("version", std::to_string (json_version)); auto result (false); @@ -96,7 +96,7 @@ bool rai::logging::upgrade_json (unsigned version_a, boost::property_tree::ptree return result; } -bool rai::logging::deserialize_json (bool & upgraded_a, boost::property_tree::ptree & tree_a) +bool nano::logging::deserialize_json (bool & upgraded_a, boost::property_tree::ptree & tree_a) { auto result (false); try @@ -142,92 +142,92 @@ bool rai::logging::deserialize_json (bool & upgraded_a, boost::property_tree::pt return result; } -bool rai::logging::ledger_logging () const +bool nano::logging::ledger_logging () const { return ledger_logging_value; } -bool rai::logging::ledger_duplicate_logging () const +bool nano::logging::ledger_duplicate_logging () const { return ledger_logging () && ledger_duplicate_logging_value; } -bool rai::logging::vote_logging () const +bool nano::logging::vote_logging () const { return vote_logging_value; } -bool rai::logging::network_logging () const +bool nano::logging::network_logging () const { return network_logging_value; } -bool rai::logging::network_message_logging () const +bool nano::logging::network_message_logging () const { return network_logging () && network_message_logging_value; } -bool rai::logging::network_publish_logging () const +bool nano::logging::network_publish_logging () const { return network_logging () && network_publish_logging_value; } -bool rai::logging::network_packet_logging () const +bool nano::logging::network_packet_logging () const { return network_logging () && network_packet_logging_value; } -bool rai::logging::network_keepalive_logging () const +bool nano::logging::network_keepalive_logging () const { return network_logging () && network_keepalive_logging_value; } -bool rai::logging::network_node_id_handshake_logging () const +bool nano::logging::network_node_id_handshake_logging () const { return network_logging () && network_node_id_handshake_logging_value; } -bool rai::logging::node_lifetime_tracing () const +bool nano::logging::node_lifetime_tracing () const { return node_lifetime_tracing_value; } -bool rai::logging::insufficient_work_logging () const +bool nano::logging::insufficient_work_logging () const { return network_logging () && insufficient_work_logging_value; } -bool rai::logging::log_rpc () const +bool nano::logging::log_rpc () const { return network_logging () && log_rpc_value; } -bool rai::logging::bulk_pull_logging () const +bool nano::logging::bulk_pull_logging () const { return network_logging () && bulk_pull_logging_value; } -bool rai::logging::callback_logging () const +bool nano::logging::callback_logging () const { return network_logging (); } -bool rai::logging::work_generation_time () const +bool nano::logging::work_generation_time () const { return work_generation_time_value; } -bool rai::logging::upnp_details_logging () const +bool nano::logging::upnp_details_logging () const { return upnp_details_logging_value; } -bool rai::logging::timing_logging () const +bool nano::logging::timing_logging () const { return timing_logging_value; } -bool rai::logging::log_to_cerr () const +bool nano::logging::log_to_cerr () const { return log_to_cerr_value; } diff --git a/rai/node/logging.hpp b/nano/node/logging.hpp similarity index 99% rename from rai/node/logging.hpp rename to nano/node/logging.hpp index 6bdb632d..ef6899b5 100644 --- a/rai/node/logging.hpp +++ b/nano/node/logging.hpp @@ -8,7 +8,7 @@ #define FATAL_LOG_PREFIX "FATAL ERROR: " -namespace rai +namespace nano { class logging { diff --git a/rai/node/node.cpp b/nano/node/node.cpp similarity index 73% rename from rai/node/node.cpp rename to nano/node/node.cpp index 14309d0d..0a254c10 100644 --- a/rai/node/node.cpp +++ b/nano/node/node.cpp @@ -1,9 +1,9 @@ -#include +#include -#include -#include -#include -#include +#include +#include +#include +#include #include #include @@ -13,39 +13,39 @@ #include #include -double constexpr rai::node::price_max; -double constexpr rai::node::free_cutoff; -std::chrono::seconds constexpr rai::node::period; -std::chrono::seconds constexpr rai::node::cutoff; -std::chrono::seconds constexpr rai::node::syn_cookie_cutoff; -std::chrono::minutes constexpr rai::node::backup_interval; -std::chrono::seconds constexpr rai::node::search_pending_interval; -int constexpr rai::port_mapping::mapping_timeout; -int constexpr rai::port_mapping::check_timeout; -unsigned constexpr rai::active_transactions::announce_interval_ms; -size_t constexpr rai::active_transactions::max_broadcast_queue; -size_t constexpr rai::block_arrival::arrival_size_min; -std::chrono::seconds constexpr rai::block_arrival::arrival_time_min; +double constexpr nano::node::price_max; +double constexpr nano::node::free_cutoff; +std::chrono::seconds constexpr nano::node::period; +std::chrono::seconds constexpr nano::node::cutoff; +std::chrono::seconds constexpr nano::node::syn_cookie_cutoff; +std::chrono::minutes constexpr nano::node::backup_interval; +std::chrono::seconds constexpr nano::node::search_pending_interval; +int constexpr nano::port_mapping::mapping_timeout; +int constexpr nano::port_mapping::check_timeout; +unsigned constexpr nano::active_transactions::announce_interval_ms; +size_t constexpr nano::active_transactions::max_broadcast_queue; +size_t constexpr nano::block_arrival::arrival_size_min; +std::chrono::seconds constexpr nano::block_arrival::arrival_time_min; -namespace rai +namespace nano { -extern unsigned char rai_bootstrap_weights[]; -extern size_t rai_bootstrap_weights_size; +extern unsigned char nano_bootstrap_weights[]; +extern size_t nano_bootstrap_weights_size; } -rai::network::network (rai::node & node_a, uint16_t port) : -buffer_container (node_a.stats, rai::network::buffer_size, 4096), // 2Mb receive buffer -socket (node_a.io_ctx, rai::endpoint (boost::asio::ip::address_v6::any (), port)), +nano::network::network (nano::node & node_a, uint16_t port) : +buffer_container (node_a.stats, nano::network::buffer_size, 4096), // 2Mb receive buffer +socket (node_a.io_ctx, nano::endpoint (boost::asio::ip::address_v6::any (), port)), resolver (node_a.io_ctx), node (node_a), on (true) { boost::thread::attributes attrs; - rai::thread_attributes::set (attrs); + nano::thread_attributes::set (attrs); for (size_t i = 0; i < node.config.network_threads; ++i) { packet_processing_threads.push_back (boost::thread (attrs, [this]() { - rai::thread_role::set (rai::thread_role::name::packet_processing); + nano::thread_role::set (nano::thread_role::name::packet_processing); try { process_packets (); @@ -78,7 +78,7 @@ on (true) } } -rai::network::~network () +nano::network::~network () { for (auto & thread : packet_processing_threads) { @@ -86,7 +86,7 @@ rai::network::~network () } } -void rai::network::start () +void nano::network::start () { for (size_t i = 0; i < node.config.io_threads; ++i) { @@ -94,7 +94,7 @@ void rai::network::start () } } -void rai::network::receive () +void nano::network::receive () { if (node.config.logging.network_packet_logging ()) { @@ -102,7 +102,7 @@ void rai::network::receive () } std::unique_lock lock (socket_mutex); auto data (buffer_container.allocate ()); - socket.async_receive_from (boost::asio::buffer (data->buffer, rai::network::buffer_size), data->endpoint, [this, data](boost::system::error_code const & error, size_t size_a) { + socket.async_receive_from (boost::asio::buffer (data->buffer, nano::network::buffer_size), data->endpoint, [this, data](boost::system::error_code const & error, size_t size_a) { if (!error && this->on) { data->size = size_a; @@ -127,7 +127,7 @@ void rai::network::receive () }); } -void rai::network::process_packets () +void nano::network::process_packets () { while (on) { @@ -142,7 +142,7 @@ void rai::network::process_packets () } } -void rai::network::stop () +void nano::network::stop () { on = false; socket.close (); @@ -150,17 +150,17 @@ void rai::network::stop () buffer_container.stop (); } -void rai::network::send_keepalive (rai::endpoint const & endpoint_a) +void nano::network::send_keepalive (nano::endpoint const & endpoint_a) { assert (endpoint_a.address ().is_v6 ()); - rai::keepalive message; + nano::keepalive message; node.peers.random_fill (message.peers); auto bytes = message.to_bytes (); if (node.config.logging.network_keepalive_logging ()) { BOOST_LOG (node.log) << boost::str (boost::format ("Keepalive req sent to %1%") % endpoint_a); } - std::weak_ptr node_w (node.shared ()); + std::weak_ptr node_w (node.shared ()); send_buffer (bytes->data (), bytes->size (), endpoint_a, [bytes, node_w, endpoint_a](boost::system::error_code const & ec, size_t) { if (auto node_l = node_w.lock ()) { @@ -170,13 +170,13 @@ void rai::network::send_keepalive (rai::endpoint const & endpoint_a) } else { - node_l->stats.inc (rai::stat::type::message, rai::stat::detail::keepalive, rai::stat::dir::out); + node_l->stats.inc (nano::stat::type::message, nano::stat::detail::keepalive, nano::stat::dir::out); } } }); } -void rai::node::keepalive (std::string const & address_a, uint16_t port_a) +void nano::node::keepalive (std::string const & address_a, uint16_t port_a) { auto node_l (shared_from_this ()); network.resolver.async_resolve (boost::asio::ip::udp::resolver::query (address_a, std::to_string (port_a)), [node_l, address_a, port_a](boost::system::error_code const & ec, boost::asio::ip::udp::resolver::iterator i_a) { @@ -184,7 +184,7 @@ void rai::node::keepalive (std::string const & address_a, uint16_t port_a) { for (auto i (i_a), n (boost::asio::ip::udp::resolver::iterator{}); i != n; ++i) { - node_l->send_keepalive (rai::map_endpoint_to_v6 (i->endpoint ())); + node_l->send_keepalive (nano::map_endpoint_to_v6 (i->endpoint ())); } } else @@ -194,23 +194,23 @@ void rai::node::keepalive (std::string const & address_a, uint16_t port_a) }); } -void rai::network::send_node_id_handshake (rai::endpoint const & endpoint_a, boost::optional const & query, boost::optional const & respond_to) +void nano::network::send_node_id_handshake (nano::endpoint const & endpoint_a, boost::optional const & query, boost::optional const & respond_to) { assert (endpoint_a.address ().is_v6 ()); - boost::optional> response (boost::none); + boost::optional> response (boost::none); if (respond_to) { - response = std::make_pair (node.node_id.pub, rai::sign_message (node.node_id.prv, node.node_id.pub, *respond_to)); - assert (!rai::validate_message (response->first, *respond_to, response->second)); + response = std::make_pair (node.node_id.pub, nano::sign_message (node.node_id.prv, node.node_id.pub, *respond_to)); + assert (!nano::validate_message (response->first, *respond_to, response->second)); } - rai::node_id_handshake message (query, response); + nano::node_id_handshake message (query, response); auto bytes = message.to_bytes (); if (node.config.logging.network_node_id_handshake_logging ()) { BOOST_LOG (node.log) << boost::str (boost::format ("Node ID handshake sent with node ID %1% to %2%: query %3%, respond_to %4% (signature %5%)") % node.node_id.pub.to_account () % endpoint_a % (query ? query->to_string () : std::string ("[none]")) % (respond_to ? respond_to->to_string () : std::string ("[none]")) % (response ? response->second.to_string () : std::string ("[none]"))); } - node.stats.inc (rai::stat::type::message, rai::stat::detail::node_id_handshake, rai::stat::dir::out); - std::weak_ptr node_w (node.shared ()); + node.stats.inc (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::out); + std::weak_ptr node_w (node.shared ()); send_buffer (bytes->data (), bytes->size (), endpoint_a, [bytes, node_w, endpoint_a](boost::system::error_code const & ec, size_t) { if (auto node_l = node_w.lock ()) { @@ -222,13 +222,13 @@ void rai::network::send_node_id_handshake (rai::endpoint const & endpoint_a, boo }); } -void rai::network::republish (rai::block_hash const & hash_a, std::shared_ptr> buffer_a, rai::endpoint endpoint_a) +void nano::network::republish (nano::block_hash const & hash_a, std::shared_ptr> buffer_a, nano::endpoint endpoint_a) { if (node.config.logging.network_publish_logging ()) { BOOST_LOG (node.log) << boost::str (boost::format ("Publishing %1% to %2%") % hash_a.to_string () % endpoint_a); } - std::weak_ptr node_w (node.shared ()); + std::weak_ptr node_w (node.shared ()); send_buffer (buffer_a->data (), buffer_a->size (), endpoint_a, [buffer_a, node_w, endpoint_a](boost::system::error_code const & ec, size_t size) { if (auto node_l = node_w.lock ()) { @@ -238,25 +238,25 @@ void rai::network::republish (rai::block_hash const & hash_a, std::shared_ptrstats.inc (rai::stat::type::message, rai::stat::detail::publish, rai::stat::dir::out); + node_l->stats.inc (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::out); } } }); } template -bool confirm_block (rai::transaction const & transaction_a, rai::node & node_a, T & list_a, std::shared_ptr block_a, bool also_publish) +bool confirm_block (nano::transaction const & transaction_a, nano::node & node_a, T & list_a, std::shared_ptr block_a, bool also_publish) { bool result (false); if (node_a.config.enable_voting) { - node_a.wallets.foreach_representative (transaction_a, [&result, &block_a, &list_a, &node_a, &transaction_a, also_publish](rai::public_key const & pub_a, rai::raw_key const & prv_a) { + node_a.wallets.foreach_representative (transaction_a, [&result, &block_a, &list_a, &node_a, &transaction_a, also_publish](nano::public_key const & pub_a, nano::raw_key const & prv_a) { result = true; auto hash (block_a->hash ()); - auto vote (node_a.store.vote_generate (transaction_a, pub_a, prv_a, std::vector (1, hash))); - rai::confirm_ack confirm (vote); + auto vote (node_a.store.vote_generate (transaction_a, pub_a, prv_a, std::vector (1, hash))); + nano::confirm_ack confirm (vote); auto vote_bytes = confirm.to_bytes (); - rai::publish publish (block_a); + nano::publish publish (block_a); std::shared_ptr> publish_bytes; if (also_publish) { @@ -275,19 +275,19 @@ bool confirm_block (rai::transaction const & transaction_a, rai::node & node_a, return result; } -bool confirm_block (rai::transaction const & transaction_a, rai::node & node_a, rai::endpoint & peer_a, std::shared_ptr block_a, bool also_publish) +bool confirm_block (nano::transaction const & transaction_a, nano::node & node_a, nano::endpoint & peer_a, std::shared_ptr block_a, bool also_publish) { - std::array endpoints; + std::array endpoints; endpoints[0] = peer_a; auto result (confirm_block (transaction_a, node_a, endpoints, std::move (block_a), also_publish)); return result; } -void rai::network::republish_block (std::shared_ptr block) +void nano::network::republish_block (std::shared_ptr block) { auto hash (block->hash ()); auto list (node.peers.list_fanout ()); - rai::publish message (block); + nano::publish message (block); auto bytes = message.to_bytes (); for (auto i (list.begin ()), n (list.end ()); i != n; ++i) { @@ -299,14 +299,14 @@ void rai::network::republish_block (std::shared_ptr block) } } -void rai::network::republish_block_batch (std::deque> blocks_a, unsigned delay_a) +void nano::network::republish_block_batch (std::deque> blocks_a, unsigned delay_a) { auto block (blocks_a.front ()); blocks_a.pop_front (); republish_block (block); if (!blocks_a.empty ()) { - std::weak_ptr node_w (node.shared ()); + std::weak_ptr node_w (node.shared ()); node.alarm.add (std::chrono::steady_clock::now () + std::chrono::milliseconds (delay_a + std::rand () % delay_a), [node_w, blocks_a, delay_a]() { if (auto node_l = node_w.lock ()) { @@ -323,9 +323,9 @@ void rai::network::republish_block_batch (std::deque // This prevents rapid publishing of votes with increasing sequence numbers. // // These rules are implemented by the caller, not this function. -void rai::network::republish_vote (std::shared_ptr vote_a) +void nano::network::republish_vote (std::shared_ptr vote_a) { - rai::confirm_ack confirm (vote_a); + nano::confirm_ack confirm (vote_a); auto bytes = confirm.to_bytes (); auto list (node.peers.list_fanout ()); for (auto j (list.begin ()), m (list.end ()); j != m; ++j) @@ -334,13 +334,13 @@ void rai::network::republish_vote (std::shared_ptr vote_a) } } -void rai::network::broadcast_confirm_req (std::shared_ptr block_a) +void nano::network::broadcast_confirm_req (std::shared_ptr block_a) { - auto list (std::make_shared> (node.peers.representatives (std::numeric_limits::max ()))); + auto list (std::make_shared> (node.peers.representatives (std::numeric_limits::max ()))); if (list->empty () || node.peers.total_weight () < node.config.online_weight_minimum.number ()) { // broadcast request to all peers - list = std::make_shared> (node.peers.list_vector (100)); + list = std::make_shared> (node.peers.list_vector (100)); } /* @@ -360,7 +360,7 @@ void rai::network::broadcast_confirm_req (std::shared_ptr block_a) broadcast_confirm_req_base (block_a, list, 0); } -void rai::network::broadcast_confirm_req_base (std::shared_ptr block_a, std::shared_ptr> endpoints_a, unsigned delay_a, bool resumption) +void nano::network::broadcast_confirm_req_base (std::shared_ptr block_a, std::shared_ptr> endpoints_a, unsigned delay_a, bool resumption) { const size_t max_reps = 10; if (!resumption && node.config.logging.network_logging ()) @@ -378,7 +378,7 @@ void rai::network::broadcast_confirm_req_base (std::shared_ptr block { delay_a += std::rand () % broadcast_interval_ms; - std::weak_ptr node_w (node.shared ()); + std::weak_ptr node_w (node.shared ()); node.alarm.add (std::chrono::steady_clock::now () + std::chrono::milliseconds (delay_a), [node_w, block_a, endpoints_a, delay_a]() { if (auto node_l = node_w.lock ()) { @@ -388,7 +388,7 @@ void rai::network::broadcast_confirm_req_base (std::shared_ptr block } } -void rai::network::broadcast_confirm_req_batch (std::deque, std::shared_ptr>>> deque_a, unsigned delay_a) +void nano::network::broadcast_confirm_req_batch (std::deque, std::shared_ptr>>> deque_a, unsigned delay_a) { auto pair (deque_a.front ()); deque_a.pop_front (); @@ -403,7 +403,7 @@ void rai::network::broadcast_confirm_req_batch (std::deque node_w (node.shared ()); + std::weak_ptr node_w (node.shared ()); node.alarm.add (std::chrono::steady_clock::now () + std::chrono::milliseconds (delay_a + std::rand () % delay_a), [node_w, deque_a, delay_a]() { if (auto node_l = node_w.lock ()) { @@ -413,16 +413,16 @@ void rai::network::broadcast_confirm_req_batch (std::deque block) +void nano::network::send_confirm_req (nano::endpoint const & endpoint_a, std::shared_ptr block) { - rai::confirm_req message (block); + nano::confirm_req message (block); auto bytes = message.to_bytes (); if (node.config.logging.network_message_logging ()) { BOOST_LOG (node.log) << boost::str (boost::format ("Sending confirm req to %1%") % endpoint_a); } - std::weak_ptr node_w (node.shared ()); - node.stats.inc (rai::stat::type::message, rai::stat::detail::confirm_req, rai::stat::dir::out); + std::weak_ptr node_w (node.shared ()); + node.stats.inc (nano::stat::type::message, nano::stat::detail::confirm_req, nano::stat::dir::out); send_buffer (bytes->data (), bytes->size (), endpoint_a, [bytes, node_w](boost::system::error_code const & ec, size_t size) { if (auto node_l = node_w.lock ()) { @@ -435,10 +435,10 @@ void rai::network::send_confirm_req (rai::endpoint const & endpoint_a, std::shar } template -void rep_query (rai::node & node_a, T const & peers_a) +void rep_query (nano::node & node_a, T const & peers_a) { auto transaction (node_a.store.tx_begin_read ()); - std::shared_ptr block (node_a.store.block_random (transaction)); + std::shared_ptr block (node_a.store.block_random (transaction)); auto hash (block->hash ()); node_a.rep_crawler.add (hash); for (auto i (peers_a.begin ()), n (peers_a.end ()); i != n; ++i) @@ -446,7 +446,7 @@ void rep_query (rai::node & node_a, T const & peers_a) node_a.peers.rep_request (*i); node_a.network.send_confirm_req (*i, block); } - std::weak_ptr node_w (node_a.shared ()); + std::weak_ptr node_w (node_a.shared ()); node_a.alarm.add (std::chrono::steady_clock::now () + std::chrono::seconds (5), [node_w, hash]() { if (auto node_l = node_w.lock ()) { @@ -455,34 +455,34 @@ void rep_query (rai::node & node_a, T const & peers_a) }); } -void rep_query (rai::node & node_a, rai::endpoint const & peers_a) +void rep_query (nano::node & node_a, nano::endpoint const & peers_a) { - std::array peers; + std::array peers; peers[0] = peers_a; rep_query (node_a, peers); } namespace { -class network_message_visitor : public rai::message_visitor +class network_message_visitor : public nano::message_visitor { public: - network_message_visitor (rai::node & node_a, rai::endpoint const & sender_a) : + network_message_visitor (nano::node & node_a, nano::endpoint const & sender_a) : node (node_a), sender (sender_a) { } virtual ~network_message_visitor () = default; - void keepalive (rai::keepalive const & message_a) override + void keepalive (nano::keepalive const & message_a) override { if (node.config.logging.network_keepalive_logging ()) { BOOST_LOG (node.log) << boost::str (boost::format ("Received keepalive message from %1%") % sender); } - node.stats.inc (rai::stat::type::message, rai::stat::detail::keepalive, rai::stat::dir::in); + node.stats.inc (nano::stat::type::message, nano::stat::detail::keepalive, nano::stat::dir::in); if (node.peers.contacted (sender, message_a.header.version_using)) { - auto endpoint_l (rai::map_endpoint_to_v6 (sender)); + auto endpoint_l (nano::map_endpoint_to_v6 (sender)); auto cookie (node.peers.assign_syn_cookie (endpoint_l)); if (cookie) { @@ -491,24 +491,24 @@ public: } node.network.merge_peers (message_a.peers); } - void publish (rai::publish const & message_a) override + void publish (nano::publish const & message_a) override { if (node.config.logging.network_message_logging ()) { BOOST_LOG (node.log) << boost::str (boost::format ("Publish message from %1% for %2%") % sender % message_a.block->hash ().to_string ()); } - node.stats.inc (rai::stat::type::message, rai::stat::detail::publish, rai::stat::dir::in); + node.stats.inc (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in); node.peers.contacted (sender, message_a.header.version_using); node.process_active (message_a.block); node.active.publish (message_a.block); } - void confirm_req (rai::confirm_req const & message_a) override + void confirm_req (nano::confirm_req const & message_a) override { if (node.config.logging.network_message_logging ()) { BOOST_LOG (node.log) << boost::str (boost::format ("Confirm_req message from %1% for %2%") % sender % message_a.block->hash ().to_string ()); } - node.stats.inc (rai::stat::type::message, rai::stat::detail::confirm_req, rai::stat::dir::in); + node.stats.inc (nano::stat::type::message, nano::stat::detail::confirm_req, nano::stat::dir::in); node.peers.contacted (sender, message_a.header.version_using); // Don't load nodes with disabled voting if (node.config.enable_voting) @@ -522,55 +522,55 @@ public: } } } - void confirm_ack (rai::confirm_ack const & message_a) override + void confirm_ack (nano::confirm_ack const & message_a) override { if (node.config.logging.network_message_logging ()) { BOOST_LOG (node.log) << boost::str (boost::format ("Received confirm_ack message from %1% for %2%sequence %3%") % sender % message_a.vote->hashes_string () % std::to_string (message_a.vote->sequence)); } - node.stats.inc (rai::stat::type::message, rai::stat::detail::confirm_ack, rai::stat::dir::in); + node.stats.inc (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::in); node.peers.contacted (sender, message_a.header.version_using); for (auto & vote_block : message_a.vote->blocks) { if (!vote_block.which ()) { - auto block (boost::get> (vote_block)); + auto block (boost::get> (vote_block)); node.process_active (block); node.active.publish (block); } } node.vote_processor.vote (message_a.vote, sender); } - void bulk_pull (rai::bulk_pull const &) override + void bulk_pull (nano::bulk_pull const &) override { assert (false); } - void bulk_pull_account (rai::bulk_pull_account const &) override + void bulk_pull_account (nano::bulk_pull_account const &) override { assert (false); } - void bulk_pull_blocks (rai::bulk_pull_blocks const &) override + void bulk_pull_blocks (nano::bulk_pull_blocks const &) override { assert (false); } - void bulk_push (rai::bulk_push const &) override + void bulk_push (nano::bulk_push const &) override { assert (false); } - void frontier_req (rai::frontier_req const &) override + void frontier_req (nano::frontier_req const &) override { assert (false); } - void node_id_handshake (rai::node_id_handshake const & message_a) override + void node_id_handshake (nano::node_id_handshake const & message_a) override { if (node.config.logging.network_node_id_handshake_logging ()) { BOOST_LOG (node.log) << boost::str (boost::format ("Received node_id_handshake message from %1% with query %2% and response account %3%") % sender % (message_a.query ? message_a.query->to_string () : std::string ("[none]")) % (message_a.response ? message_a.response->first.to_account () : std::string ("[none]"))); } - node.stats.inc (rai::stat::type::message, rai::stat::detail::node_id_handshake, rai::stat::dir::in); - auto endpoint_l (rai::map_endpoint_to_v6 (sender)); - boost::optional out_query; - boost::optional out_respond_to; + node.stats.inc (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in); + auto endpoint_l (nano::map_endpoint_to_v6 (sender)); + boost::optional out_query; + boost::optional out_respond_to; if (message_a.query) { out_respond_to = message_a.query; @@ -600,68 +600,68 @@ public: node.network.send_node_id_handshake (sender, out_query, out_respond_to); } } - rai::node & node; - rai::endpoint sender; + nano::node & node; + nano::endpoint sender; }; } -void rai::network::receive_action (rai::udp_data * data_a) +void nano::network::receive_action (nano::udp_data * data_a) { auto allowed_sender (true); if (data_a->endpoint == endpoint ()) { allowed_sender = false; } - else if (rai::reserved_address (data_a->endpoint, false) && !node.config.allow_local_peers) + else if (nano::reserved_address (data_a->endpoint, false) && !node.config.allow_local_peers) { allowed_sender = false; } if (allowed_sender) { network_message_visitor visitor (node, data_a->endpoint); - rai::message_parser parser (node.block_uniquer, node.vote_uniquer, visitor, node.work); + nano::message_parser parser (node.block_uniquer, node.vote_uniquer, visitor, node.work); parser.deserialize_buffer (data_a->buffer, data_a->size); - if (parser.status != rai::message_parser::parse_status::success) + if (parser.status != nano::message_parser::parse_status::success) { - node.stats.inc (rai::stat::type::error); + node.stats.inc (nano::stat::type::error); switch (parser.status) { - case rai::message_parser::parse_status::insufficient_work: + case nano::message_parser::parse_status::insufficient_work: // We've already increment error count, update detail only - node.stats.inc_detail_only (rai::stat::type::error, rai::stat::detail::insufficient_work); + node.stats.inc_detail_only (nano::stat::type::error, nano::stat::detail::insufficient_work); break; - case rai::message_parser::parse_status::invalid_magic: - node.stats.inc (rai::stat::type::udp, rai::stat::detail::invalid_magic); + case nano::message_parser::parse_status::invalid_magic: + node.stats.inc (nano::stat::type::udp, nano::stat::detail::invalid_magic); break; - case rai::message_parser::parse_status::invalid_network: - node.stats.inc (rai::stat::type::udp, rai::stat::detail::invalid_network); + case nano::message_parser::parse_status::invalid_network: + node.stats.inc (nano::stat::type::udp, nano::stat::detail::invalid_network); break; - case rai::message_parser::parse_status::invalid_header: - node.stats.inc (rai::stat::type::udp, rai::stat::detail::invalid_header); + case nano::message_parser::parse_status::invalid_header: + node.stats.inc (nano::stat::type::udp, nano::stat::detail::invalid_header); break; - case rai::message_parser::parse_status::invalid_message_type: - node.stats.inc (rai::stat::type::udp, rai::stat::detail::invalid_message_type); + case nano::message_parser::parse_status::invalid_message_type: + node.stats.inc (nano::stat::type::udp, nano::stat::detail::invalid_message_type); break; - case rai::message_parser::parse_status::invalid_keepalive_message: - node.stats.inc (rai::stat::type::udp, rai::stat::detail::invalid_keepalive_message); + case nano::message_parser::parse_status::invalid_keepalive_message: + node.stats.inc (nano::stat::type::udp, nano::stat::detail::invalid_keepalive_message); break; - case rai::message_parser::parse_status::invalid_publish_message: - node.stats.inc (rai::stat::type::udp, rai::stat::detail::invalid_publish_message); + case nano::message_parser::parse_status::invalid_publish_message: + node.stats.inc (nano::stat::type::udp, nano::stat::detail::invalid_publish_message); break; - case rai::message_parser::parse_status::invalid_confirm_req_message: - node.stats.inc (rai::stat::type::udp, rai::stat::detail::invalid_confirm_req_message); + case nano::message_parser::parse_status::invalid_confirm_req_message: + node.stats.inc (nano::stat::type::udp, nano::stat::detail::invalid_confirm_req_message); break; - case rai::message_parser::parse_status::invalid_confirm_ack_message: - node.stats.inc (rai::stat::type::udp, rai::stat::detail::invalid_confirm_ack_message); + case nano::message_parser::parse_status::invalid_confirm_ack_message: + node.stats.inc (nano::stat::type::udp, nano::stat::detail::invalid_confirm_ack_message); break; - case rai::message_parser::parse_status::invalid_node_id_handshake_message: - node.stats.inc (rai::stat::type::udp, rai::stat::detail::invalid_node_id_handshake_message); + case nano::message_parser::parse_status::invalid_node_id_handshake_message: + node.stats.inc (nano::stat::type::udp, nano::stat::detail::invalid_node_id_handshake_message); break; - case rai::message_parser::parse_status::outdated_version: - node.stats.inc (rai::stat::type::udp, rai::stat::detail::outdated_version); + case nano::message_parser::parse_status::outdated_version: + node.stats.inc (nano::stat::type::udp, nano::stat::detail::outdated_version); break; - case rai::message_parser::parse_status::success: + case nano::message_parser::parse_status::success: /* Already checked, unreachable */ break; } @@ -673,7 +673,7 @@ void rai::network::receive_action (rai::udp_data * data_a) } else { - node.stats.add (rai::stat::type::traffic, rai::stat::dir::in, data_a->size); + node.stats.add (nano::stat::type::traffic, nano::stat::dir::in, data_a->size); } } else @@ -683,12 +683,12 @@ void rai::network::receive_action (rai::udp_data * data_a) BOOST_LOG (node.log) << boost::str (boost::format ("Reserved sender %1%") % data_a->endpoint.address ().to_string ()); } - node.stats.inc_detail_only (rai::stat::type::error, rai::stat::detail::bad_sender); + node.stats.inc_detail_only (nano::stat::type::error, nano::stat::detail::bad_sender); } } // Send keepalives to all the peers we've been notified of -void rai::network::merge_peers (std::array const & peers_a) +void nano::network::merge_peers (std::array const & peers_a) { for (auto i (peers_a.begin ()), j (peers_a.end ()); i != j; ++i) { @@ -699,27 +699,27 @@ void rai::network::merge_peers (std::array const & peers_a) } } -bool rai::operation::operator> (rai::operation const & other_a) const +bool nano::operation::operator> (nano::operation const & other_a) const { return wakeup > other_a.wakeup; } -rai::alarm::alarm (boost::asio::io_context & io_ctx_a) : +nano::alarm::alarm (boost::asio::io_context & io_ctx_a) : io_ctx (io_ctx_a), thread ([this]() { - rai::thread_role::set (rai::thread_role::name::alarm); + nano::thread_role::set (nano::thread_role::name::alarm); run (); }) { } -rai::alarm::~alarm () +nano::alarm::~alarm () { add (std::chrono::steady_clock::now (), nullptr); thread.join (); } -void rai::alarm::run () +void nano::alarm::run () { std::unique_lock lock (mutex); auto done (false); @@ -753,33 +753,33 @@ void rai::alarm::run () } } -void rai::alarm::add (std::chrono::steady_clock::time_point const & wakeup_a, std::function const & operation) +void nano::alarm::add (std::chrono::steady_clock::time_point const & wakeup_a, std::function const & operation) { { std::lock_guard lock (mutex); - operations.push (rai::operation ({ wakeup_a, operation })); + operations.push (nano::operation ({ wakeup_a, operation })); } condition.notify_all (); } -rai::node_init::node_init () : +nano::node_init::node_init () : block_store_init (false), wallet_init (false) { } -bool rai::node_init::error () +bool nano::node_init::error () { return block_store_init || wallet_init; } -rai::vote_processor::vote_processor (rai::node & node_a) : +nano::vote_processor::vote_processor (nano::node & node_a) : node (node_a), started (false), stopped (false), active (false), thread ([this]() { - rai::thread_role::set (rai::thread_role::name::vote_processing); + nano::thread_role::set (nano::thread_role::name::vote_processing); process_loop (); }) { @@ -790,7 +790,7 @@ thread ([this]() { } } -void rai::vote_processor::process_loop () +void nano::vote_processor::process_loop () { std::chrono::steady_clock::time_point start_time, end_time; std::chrono::steady_clock::duration elapsed_time; @@ -809,7 +809,7 @@ void rai::vote_processor::process_loop () { if (!votes.empty ()) { - std::deque, rai::endpoint>> votes_l; + std::deque, nano::endpoint>> votes_l; votes_l.swap (votes); log_this_iteration = false; @@ -873,7 +873,7 @@ void rai::vote_processor::process_loop () } } -void rai::vote_processor::vote (std::shared_ptr vote_a, rai::endpoint endpoint_a) +void nano::vote_processor::vote (std::shared_ptr vote_a, nano::endpoint endpoint_a) { assert (endpoint_a.address ().is_v6 ()); std::unique_lock lock (mutex); @@ -883,7 +883,7 @@ void rai::vote_processor::vote (std::shared_ptr vote_a, rai::endpoint /* Random early delection levels Always process votes for test network (process = true) Stop processing with max 144 * 1024 votes */ - if (rai::rai_network != rai::rai_networks::rai_test_network) + if (nano::nano_network != nano::nano_networks::nano_test_network) { // Level 0 (< 0.1%) if (votes.size () < 96 * 1024) @@ -921,7 +921,7 @@ void rai::vote_processor::vote (std::shared_ptr vote_a, rai::endpoint } else { - node.stats.inc (rai::stat::type::vote, rai::stat::detail::vote_overflow); + node.stats.inc (nano::stat::type::vote, nano::stat::detail::vote_overflow); if (node.config.logging.vote_logging ()) { BOOST_LOG (node.log) << "Votes overflow"; @@ -930,14 +930,14 @@ void rai::vote_processor::vote (std::shared_ptr vote_a, rai::endpoint } } -void rai::vote_processor::verify_votes (std::deque, rai::endpoint>> & votes_a) +void nano::vote_processor::verify_votes (std::deque, nano::endpoint>> & votes_a) { auto size (votes_a.size ()); std::vector messages; messages.reserve (size); - std::vector hashes; + std::vector hashes; hashes.reserve (size); - std::vector lengths (size, sizeof (rai::uint256_union)); + std::vector lengths (size, sizeof (nano::uint256_union)); std::vector pub_keys; pub_keys.reserve (size); std::vector signatures; @@ -952,7 +952,7 @@ void rai::vote_processor::verify_votes (std::dequesignature.bytes.data ()); } std::promise promise; - rai::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data (), &promise }; + nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data (), &promise }; node.checker.add (check); promise.get_future ().wait (); std::remove_reference_t result; @@ -970,34 +970,34 @@ void rai::vote_processor::verify_votes (std::deque vote_a, rai::endpoint endpoint_a, bool validated) +nano::vote_code nano::vote_processor::vote_blocking (nano::transaction const & transaction_a, std::shared_ptr vote_a, nano::endpoint endpoint_a, bool validated) { assert (endpoint_a.address ().is_v6 ()); assert (!node.active.mutex.try_lock ()); - auto result (rai::vote_code::invalid); + auto result (nano::vote_code::invalid); if (validated || !vote_a->validate ()) { auto max_vote (node.store.vote_max (transaction_a, vote_a)); - result = rai::vote_code::replay; + result = nano::vote_code::replay; if (!node.active.vote (vote_a, true)) { - result = rai::vote_code::vote; + result = nano::vote_code::vote; } switch (result) { - case rai::vote_code::vote: + case nano::vote_code::vote: node.observers.vote.notify (transaction_a, vote_a, endpoint_a); - case rai::vote_code::replay: + case nano::vote_code::replay: // This tries to assist rep nodes that have lost track of their highest sequence number by replaying our highest known vote back to them // Only do this if the sequence number is significantly different to account for network reordering // Amplify attack considerations: We're sending out a confirm_ack in response to a confirm_ack for no net traffic increase if (max_vote->sequence > vote_a->sequence + 10000) { - rai::confirm_ack confirm (max_vote); + nano::confirm_ack confirm (max_vote); node.network.confirm_send (confirm, confirm.to_bytes (), endpoint_a); } break; - case rai::vote_code::invalid: + case nano::vote_code::invalid: assert (false); break; } @@ -1005,17 +1005,17 @@ rai::vote_code rai::vote_processor::vote_blocking (rai::transaction const & tran std::string status; switch (result) { - case rai::vote_code::invalid: + case nano::vote_code::invalid: status = "Invalid"; - node.stats.inc (rai::stat::type::vote, rai::stat::detail::vote_invalid); + node.stats.inc (nano::stat::type::vote, nano::stat::detail::vote_invalid); break; - case rai::vote_code::replay: + case nano::vote_code::replay: status = "Replay"; - node.stats.inc (rai::stat::type::vote, rai::stat::detail::vote_replay); + node.stats.inc (nano::stat::type::vote, nano::stat::detail::vote_replay); break; - case rai::vote_code::vote: + case nano::vote_code::vote: status = "Vote"; - node.stats.inc (rai::stat::type::vote, rai::stat::detail::vote_valid); + node.stats.inc (nano::stat::type::vote, nano::stat::detail::vote_valid); break; } if (node.config.logging.vote_logging ()) @@ -1025,7 +1025,7 @@ rai::vote_code rai::vote_processor::vote_blocking (rai::transaction const & tran return result; } -void rai::vote_processor::stop () +void nano::vote_processor::stop () { { std::lock_guard lock (mutex); @@ -1038,7 +1038,7 @@ void rai::vote_processor::stop () } } -void rai::vote_processor::flush () +void nano::vote_processor::flush () { std::unique_lock lock (mutex); while (active || !votes.empty ()) @@ -1047,7 +1047,7 @@ void rai::vote_processor::flush () } } -void rai::vote_processor::calculate_weights () +void nano::vote_processor::calculate_weights () { std::unique_lock lock (mutex); if (!stopped) @@ -1059,7 +1059,7 @@ void rai::vote_processor::calculate_weights () auto transaction (node.store.tx_begin_read ()); for (auto i (node.store.representation_begin (transaction)), n (node.store.representation_end ()); i != n; ++i) { - rai::account representative (i->first); + nano::account representative (i->first); auto weight (node.ledger.weight (transaction, representative)); if (weight > supply / 1000) // 0.1% or above (level 1) { @@ -1077,25 +1077,25 @@ void rai::vote_processor::calculate_weights () } } -void rai::rep_crawler::add (rai::block_hash const & hash_a) +void nano::rep_crawler::add (nano::block_hash const & hash_a) { std::lock_guard lock (mutex); active.insert (hash_a); } -void rai::rep_crawler::remove (rai::block_hash const & hash_a) +void nano::rep_crawler::remove (nano::block_hash const & hash_a) { std::lock_guard lock (mutex); active.erase (hash_a); } -bool rai::rep_crawler::exists (rai::block_hash const & hash_a) +bool nano::rep_crawler::exists (nano::block_hash const & hash_a) { std::lock_guard lock (mutex); return active.count (hash_a) != 0; } -rai::signature_checker::signature_checker () : +nano::signature_checker::signature_checker () : started (false), stopped (false), thread ([this]() { run (); }) @@ -1107,12 +1107,12 @@ thread ([this]() { run (); }) } } -rai::signature_checker::~signature_checker () +nano::signature_checker::~signature_checker () { stop (); } -void rai::signature_checker::add (rai::signature_check_set & check_a) +void nano::signature_checker::add (nano::signature_check_set & check_a) { { std::lock_guard lock (mutex); @@ -1121,7 +1121,7 @@ void rai::signature_checker::add (rai::signature_check_set & check_a) condition.notify_all (); } -void rai::signature_checker::stop () +void nano::signature_checker::stop () { std::unique_lock lock (mutex); stopped = true; @@ -1133,7 +1133,7 @@ void rai::signature_checker::stop () } } -void rai::signature_checker::flush () +void nano::signature_checker::flush () { std::unique_lock lock (mutex); while (!stopped && !checks.empty ()) @@ -1142,19 +1142,19 @@ void rai::signature_checker::flush () } } -void rai::signature_checker::verify (rai::signature_check_set & check_a) +void nano::signature_checker::verify (nano::signature_check_set & check_a) { /* Verifications is vector if signatures check results validate_message_batch returing "true" if there are at least 1 invalid signature */ - auto code (rai::validate_message_batch (check_a.messages, check_a.message_lengths, check_a.pub_keys, check_a.signatures, check_a.size, check_a.verifications)); + auto code (nano::validate_message_batch (check_a.messages, check_a.message_lengths, check_a.pub_keys, check_a.signatures, check_a.size, check_a.verifications)); (void)code; release_assert (std::all_of (check_a.verifications, check_a.verifications + check_a.size, [](int verification) { return verification == 0 || verification == 1; })); check_a.promise->set_value (); } -void rai::signature_checker::run () +void nano::signature_checker::run () { - rai::thread_role::set (rai::thread_role::name::signature_checking); + nano::thread_role::set (nano::thread_role::name::signature_checking); std::unique_lock lock (mutex); started = true; @@ -1180,21 +1180,21 @@ void rai::signature_checker::run () } } -rai::block_processor::block_processor (rai::node & node_a) : +nano::block_processor::block_processor (nano::node & node_a) : stopped (false), active (false), next_log (std::chrono::steady_clock::now ()), node (node_a), -generator (node_a, rai::rai_network == rai::rai_networks::rai_test_network ? std::chrono::milliseconds (10) : std::chrono::milliseconds (500)) +generator (node_a, nano::nano_network == nano::nano_networks::nano_test_network ? std::chrono::milliseconds (10) : std::chrono::milliseconds (500)) { } -rai::block_processor::~block_processor () +nano::block_processor::~block_processor () { stop (); } -void rai::block_processor::stop () +void nano::block_processor::stop () { generator.stop (); { @@ -1204,7 +1204,7 @@ void rai::block_processor::stop () condition.notify_all (); } -void rai::block_processor::flush () +void nano::block_processor::flush () { node.checker.flush (); std::unique_lock lock (mutex); @@ -1214,21 +1214,21 @@ void rai::block_processor::flush () } } -bool rai::block_processor::full () +bool nano::block_processor::full () { std::unique_lock lock (mutex); return (blocks.size () + state_blocks.size ()) > 16384; } -void rai::block_processor::add (std::shared_ptr block_a, std::chrono::steady_clock::time_point origination) +void nano::block_processor::add (std::shared_ptr block_a, std::chrono::steady_clock::time_point origination) { - if (!rai::work_validate (block_a->root (), block_a->block_work ())) + if (!nano::work_validate (block_a->root (), block_a->block_work ())) { { std::lock_guard lock (mutex); if (blocks_hashes.find (block_a->hash ()) == blocks_hashes.end ()) { - if (block_a->type () == rai::block_type::state && !node.ledger.is_epoch_link (block_a->link ())) + if (block_a->type () == nano::block_type::state && !node.ledger.is_epoch_link (block_a->link ())) { state_blocks.push_back (std::make_pair (block_a, origination)); } @@ -1242,12 +1242,12 @@ void rai::block_processor::add (std::shared_ptr block_a, std::chrono } else { - BOOST_LOG (node.log) << "rai::block_processor::add called for hash " << block_a->hash ().to_string () << " with invalid work " << rai::to_string_hex (block_a->block_work ()); - assert (false && "rai::block_processor::add called with invalid work"); + BOOST_LOG (node.log) << "nano::block_processor::add called for hash " << block_a->hash ().to_string () << " with invalid work " << nano::to_string_hex (block_a->block_work ()); + assert (false && "nano::block_processor::add called with invalid work"); } } -void rai::block_processor::force (std::shared_ptr block_a) +void nano::block_processor::force (std::shared_ptr block_a) { { std::lock_guard lock (mutex); @@ -1256,7 +1256,7 @@ void rai::block_processor::force (std::shared_ptr block_a) condition.notify_all (); } -void rai::block_processor::process_blocks () +void nano::block_processor::process_blocks () { std::unique_lock lock (mutex); while (!stopped) @@ -1280,7 +1280,7 @@ void rai::block_processor::process_blocks () } } -bool rai::block_processor::should_log (bool first_time) +bool nano::block_processor::should_log (bool first_time) { auto result (false); auto now (std::chrono::steady_clock::now ()); @@ -1292,17 +1292,17 @@ bool rai::block_processor::should_log (bool first_time) return result; } -bool rai::block_processor::have_blocks () +bool nano::block_processor::have_blocks () { assert (!mutex.try_lock ()); return !blocks.empty () || !forced.empty () || !state_blocks.empty (); } -void rai::block_processor::verify_state_blocks (std::unique_lock & lock_a, size_t max_count) +void nano::block_processor::verify_state_blocks (std::unique_lock & lock_a, size_t max_count) { assert (!mutex.try_lock ()); auto start_time (std::chrono::steady_clock::now ()); - std::deque, std::chrono::steady_clock::time_point>> items; + std::deque, std::chrono::steady_clock::time_point>> items; if (max_count == std::numeric_limits::max () || max_count >= state_blocks.size ()) { items.swap (state_blocks); @@ -1317,7 +1317,7 @@ void rai::block_processor::verify_state_blocks (std::unique_lock & l } lock_a.unlock (); auto size (items.size ()); - std::vector hashes; + std::vector hashes; hashes.reserve (size); std::vector messages; messages.reserve (size); @@ -1331,7 +1331,7 @@ void rai::block_processor::verify_state_blocks (std::unique_lock & l verifications.resize (size, 0); for (auto i (0); i < size; ++i) { - auto & block (static_cast (*items[i].first)); + auto & block (static_cast (*items[i].first)); hashes.push_back (block.hash ()); messages.push_back (hashes.back ().bytes.data ()); lengths.push_back (sizeof (decltype (hashes)::value_type)); @@ -1339,7 +1339,7 @@ void rai::block_processor::verify_state_blocks (std::unique_lock & l signatures.push_back (block.signature.bytes.data ()); } std::promise promise; - rai::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data (), &promise }; + nano::signature_check_set check = { size, messages.data (), lengths.data (), pub_keys.data (), signatures.data (), verifications.data (), &promise }; node.checker.add (check); promise.get_future ().wait (); lock_a.lock (); @@ -1362,7 +1362,7 @@ void rai::block_processor::verify_state_blocks (std::unique_lock & l } } -void rai::block_processor::process_receive_many (std::unique_lock & lock_a) +void nano::block_processor::process_receive_many (std::unique_lock & lock_a) { lock_a.lock (); auto start_time (std::chrono::steady_clock::now ()); @@ -1401,7 +1401,7 @@ void rai::block_processor::process_receive_many (std::unique_lock & first_time = false; BOOST_LOG (node.log) << boost::str (boost::format ("%1% blocks (+ %2% state blocks) (+ %3% forced) in processing queue") % blocks.size () % state_blocks.size () % forced.size ()); } - std::pair, std::chrono::steady_clock::time_point> block; + std::pair, std::chrono::steady_clock::time_point> block; bool force (false); if (forced.empty ()) { @@ -1430,7 +1430,7 @@ void rai::block_processor::process_receive_many (std::unique_lock & } /* Forced state blocks are not validated in verify_state_blocks () function Because of that we should set set validated_state_block as "false" for forced state blocks (!force) */ - bool validated_state_block (!force && block.first->type () == rai::block_type::state); + bool validated_state_block (!force && block.first->type () == nano::block_type::state); auto process_result (process_receive_one (transaction, block.first, block.second, validated_state_block)); number_of_blocks_processed++; (void)process_result; @@ -1454,14 +1454,14 @@ void rai::block_processor::process_receive_many (std::unique_lock & } } -rai::process_return rai::block_processor::process_receive_one (rai::transaction const & transaction_a, std::shared_ptr block_a, std::chrono::steady_clock::time_point origination, bool validated_state_block) +nano::process_return nano::block_processor::process_receive_one (nano::transaction const & transaction_a, std::shared_ptr block_a, std::chrono::steady_clock::time_point origination, bool validated_state_block) { - rai::process_return result; + nano::process_return result; auto hash (block_a->hash ()); result = node.ledger.process (transaction_a, *block_a, validated_state_block); switch (result.code) { - case rai::process_result::progress: + case nano::process_result::progress: { if (node.config.logging.ledger_logging ()) { @@ -1480,7 +1480,7 @@ rai::process_return rai::block_processor::process_receive_one (rai::transaction queue_unchecked (transaction_a, hash); break; } - case rai::process_result::gap_previous: + case nano::process_result::gap_previous: { if (node.config.logging.ledger_logging ()) { @@ -1490,7 +1490,7 @@ rai::process_return rai::block_processor::process_receive_one (rai::transaction node.gap_cache.add (transaction_a, block_a); break; } - case rai::process_result::gap_source: + case nano::process_result::gap_source: { if (node.config.logging.ledger_logging ()) { @@ -1500,7 +1500,7 @@ rai::process_return rai::block_processor::process_receive_one (rai::transaction node.gap_cache.add (transaction_a, block_a); break; } - case rai::process_result::old: + case nano::process_result::old: { if (node.config.logging.ledger_duplicate_logging ()) { @@ -1510,7 +1510,7 @@ rai::process_return rai::block_processor::process_receive_one (rai::transaction node.active.update_difficulty (*block_a); break; } - case rai::process_result::bad_signature: + case nano::process_result::bad_signature: { if (node.config.logging.ledger_logging ()) { @@ -1518,7 +1518,7 @@ rai::process_return rai::block_processor::process_receive_one (rai::transaction } break; } - case rai::process_result::negative_spend: + case nano::process_result::negative_spend: { if (node.config.logging.ledger_logging ()) { @@ -1526,7 +1526,7 @@ rai::process_return rai::block_processor::process_receive_one (rai::transaction } break; } - case rai::process_result::unreceivable: + case nano::process_result::unreceivable: { if (node.config.logging.ledger_logging ()) { @@ -1534,7 +1534,7 @@ rai::process_return rai::block_processor::process_receive_one (rai::transaction } break; } - case rai::process_result::fork: + case nano::process_result::fork: { if (origination < std::chrono::steady_clock::now () - std::chrono::seconds (15)) { @@ -1547,12 +1547,12 @@ rai::process_return rai::block_processor::process_receive_one (rai::transaction } break; } - case rai::process_result::opened_burn_account: + case nano::process_result::opened_burn_account: { BOOST_LOG (node.log) << boost::str (boost::format ("*** Rejecting open block for burn account ***: %1%") % hash.to_string ()); break; } - case rai::process_result::balance_mismatch: + case nano::process_result::balance_mismatch: { if (node.config.logging.ledger_logging ()) { @@ -1560,7 +1560,7 @@ rai::process_return rai::block_processor::process_receive_one (rai::transaction } break; } - case rai::process_result::representative_mismatch: + case nano::process_result::representative_mismatch: { if (node.config.logging.ledger_logging ()) { @@ -1568,7 +1568,7 @@ rai::process_return rai::block_processor::process_receive_one (rai::transaction } break; } - case rai::process_result::block_position: + case nano::process_result::block_position: { if (node.config.logging.ledger_logging ()) { @@ -1580,29 +1580,29 @@ rai::process_return rai::block_processor::process_receive_one (rai::transaction return result; } -void rai::block_processor::queue_unchecked (rai::transaction const & transaction_a, rai::block_hash const & hash_a) +void nano::block_processor::queue_unchecked (nano::transaction const & transaction_a, nano::block_hash const & hash_a) { auto cached (node.store.unchecked_get (transaction_a, hash_a)); for (auto i (cached.begin ()), n (cached.end ()); i != n; ++i) { - node.store.unchecked_del (transaction_a, rai::unchecked_key (hash_a, (*i)->hash ())); + node.store.unchecked_del (transaction_a, nano::unchecked_key (hash_a, (*i)->hash ())); add (*i, std::chrono::steady_clock::time_point ()); } std::lock_guard lock (node.gap_cache.mutex); node.gap_cache.blocks.get<1> ().erase (hash_a); } -rai::node::node (rai::node_init & init_a, boost::asio::io_context & io_ctx_a, uint16_t peering_port_a, boost::filesystem::path const & application_path_a, rai::alarm & alarm_a, rai::logging const & logging_a, rai::work_pool & work_a) : -node (init_a, io_ctx_a, application_path_a, alarm_a, rai::node_config (peering_port_a, logging_a), work_a) +nano::node::node (nano::node_init & init_a, boost::asio::io_context & io_ctx_a, uint16_t peering_port_a, boost::filesystem::path const & application_path_a, nano::alarm & alarm_a, nano::logging const & logging_a, nano::work_pool & work_a) : +node (init_a, io_ctx_a, application_path_a, alarm_a, nano::node_config (peering_port_a, logging_a), work_a) { } -rai::node::node (rai::node_init & init_a, boost::asio::io_context & io_ctx_a, boost::filesystem::path const & application_path_a, rai::alarm & alarm_a, rai::node_config const & config_a, rai::work_pool & work_a) : +nano::node::node (nano::node_init & init_a, boost::asio::io_context & io_ctx_a, boost::filesystem::path const & application_path_a, nano::alarm & alarm_a, nano::node_config const & config_a, nano::work_pool & work_a) : io_ctx (io_ctx_a), config (config_a), alarm (alarm_a), work (work_a), -store_impl (std::make_unique (init_a.block_store_init, application_path_a / "data.ldb", config_a.lmdb_max_dbs)), +store_impl (std::make_unique (init_a.block_store_init, application_path_a / "data.ldb", config_a.lmdb_max_dbs)), store (*store_impl), gap_cache (*this), ledger (store, stats, config.epoch_block_link, config.epoch_block_signer), @@ -1618,7 +1618,7 @@ vote_processor (*this), warmed_up (0), block_processor (*this), block_processor_thread ([this]() { - rai::thread_role::set (rai::thread_role::name::block_processing); + nano::thread_role::set (nano::thread_role::name::block_processing); this->block_processor.process_blocks (); }), online_reps (*this), @@ -1628,7 +1628,7 @@ vote_uniquer (block_uniquer) wallets.observer = [this](bool active) { observers.wallet.notify (active); }; - peers.peer_observer = [this](rai::endpoint const & endpoint_a) { + peers.peer_observer = [this](nano::endpoint const & endpoint_a) { observers.endpoint.notify (endpoint_a); }; peers.disconnect_observer = [this]() { @@ -1636,7 +1636,7 @@ vote_uniquer (block_uniquer) }; if (!config.callback_address.empty ()) { - observers.blocks.add ([this](std::shared_ptr block_a, rai::account const & account_a, rai::amount const & amount_a, bool is_state_send_a) { + observers.blocks.add ([this](std::shared_ptr block_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a) { if (this->block_arrival.recent (block_a->hash ())) { auto node_l (shared_from_this ()); @@ -1689,7 +1689,7 @@ vote_uniquer (block_uniquer) { if (resp->result () == boost::beast::http::status::ok) { - node_l->stats.inc (rai::stat::type::http_callback, rai::stat::detail::initiate, rai::stat::dir::out); + node_l->stats.inc (nano::stat::type::http_callback, nano::stat::detail::initiate, nano::stat::dir::out); } else { @@ -1697,7 +1697,7 @@ vote_uniquer (block_uniquer) { BOOST_LOG (node_l->log) << boost::str (boost::format ("Callback to %1%:%2% failed with status: %3%") % address % port % resp->result ()); } - node_l->stats.inc (rai::stat::type::error, rai::stat::detail::http_callback, rai::stat::dir::out); + node_l->stats.inc (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out); } } else @@ -1706,7 +1706,7 @@ vote_uniquer (block_uniquer) { BOOST_LOG (node_l->log) << boost::str (boost::format ("Unable complete callback: %1%:%2%: %3%") % address % port % ec.message ()); } - node_l->stats.inc (rai::stat::type::error, rai::stat::detail::http_callback, rai::stat::dir::out); + node_l->stats.inc (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out); }; }); } @@ -1716,7 +1716,7 @@ vote_uniquer (block_uniquer) { BOOST_LOG (node_l->log) << boost::str (boost::format ("Unable to send callback: %1%:%2%: %3%") % address % port % ec.message ()); } - node_l->stats.inc (rai::stat::type::error, rai::stat::detail::http_callback, rai::stat::dir::out); + node_l->stats.inc (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out); } }); } @@ -1726,7 +1726,7 @@ vote_uniquer (block_uniquer) { BOOST_LOG (node_l->log) << boost::str (boost::format ("Unable to connect to callback address: %1%:%2%: %3%") % address % port % ec.message ()); } - node_l->stats.inc (rai::stat::type::error, rai::stat::detail::http_callback, rai::stat::dir::out); + node_l->stats.inc (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out); } }); } @@ -1737,23 +1737,23 @@ vote_uniquer (block_uniquer) { BOOST_LOG (node_l->log) << boost::str (boost::format ("Error resolving callback: %1%:%2%: %3%") % address % port % ec.message ()); } - node_l->stats.inc (rai::stat::type::error, rai::stat::detail::http_callback, rai::stat::dir::out); + node_l->stats.inc (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out); } }); }); } }); } - observers.endpoint.add ([this](rai::endpoint const & endpoint_a) { + observers.endpoint.add ([this](nano::endpoint const & endpoint_a) { this->network.send_keepalive (endpoint_a); rep_query (*this, endpoint_a); }); - observers.vote.add ([this](rai::transaction const & transaction, std::shared_ptr vote_a, rai::endpoint const & endpoint_a) { + observers.vote.add ([this](nano::transaction const & transaction, std::shared_ptr vote_a, nano::endpoint const & endpoint_a) { assert (endpoint_a.address ().is_v6 ()); this->gap_cache.vote (vote_a); this->online_reps.vote (vote_a); - rai::uint128_t rep_weight; - rai::uint128_t min_rep_weight; + nano::uint128_t rep_weight; + nano::uint128_t min_rep_weight; { rep_weight = ledger.weight (transaction, vote_a->account); min_rep_weight = online_reps.online_stake () / 1000; @@ -1788,7 +1788,7 @@ vote_uniquer (block_uniquer) } } }); - BOOST_LOG (log) << "Node starting, version: " << RAIBLOCKS_VERSION_MAJOR << "." << RAIBLOCKS_VERSION_MINOR; + BOOST_LOG (log) << "Node starting, version: " << NANO_VERSION_MAJOR << "." << NANO_VERSION_MINOR; BOOST_LOG (log) << boost::str (boost::format ("Work pool running %1% threads") % work.threads.size ()); if (!init_a.error ()) { @@ -1796,7 +1796,7 @@ vote_uniquer (block_uniquer) { BOOST_LOG (log) << "Constructing node"; } - rai::genesis genesis; + nano::genesis genesis; auto transaction (store.tx_begin_write ()); if (store.latest_begin (transaction) == store.latest_end ()) { @@ -1809,15 +1809,15 @@ vote_uniquer (block_uniquer) std::exit (1); } - node_id = rai::keypair (store.get_node_id (transaction)); + node_id = nano::keypair (store.get_node_id (transaction)); BOOST_LOG (log) << "Node ID: " << node_id.pub.to_account (); } peers.online_weight_minimum = config.online_weight_minimum.number (); - if (rai::rai_network == rai::rai_networks::rai_live_network || rai::rai_network == rai::rai_networks::rai_beta_network) + if (nano::nano_network == nano::nano_networks::nano_live_network || nano::nano_network == nano::nano_networks::nano_beta_network) { - rai::bufferstream weight_stream ((const uint8_t *)rai_bootstrap_weights, rai_bootstrap_weights_size); - rai::uint128_union block_height; - if (!rai::read (weight_stream, block_height)) + nano::bufferstream weight_stream ((const uint8_t *)nano_bootstrap_weights, nano_bootstrap_weights_size); + nano::uint128_union block_height; + if (!nano::read (weight_stream, block_height)) { auto max_blocks = (uint64_t)block_height.number (); auto transaction (store.tx_begin_read ()); @@ -1826,13 +1826,13 @@ vote_uniquer (block_uniquer) ledger.bootstrap_weight_max_blocks = max_blocks; while (true) { - rai::account account; - if (rai::read (weight_stream, account.bytes)) + nano::account account; + if (nano::read (weight_stream, account.bytes)) { break; } - rai::amount weight; - if (rai::read (weight_stream, weight.bytes)) + nano::amount weight; + if (nano::read (weight_stream, weight.bytes)) { break; } @@ -1844,7 +1844,7 @@ vote_uniquer (block_uniquer) } } -rai::node::~node () +nano::node::~node () { if (config.logging.node_lifetime_tracing ()) { @@ -1853,26 +1853,26 @@ rai::node::~node () stop (); } -bool rai::node::copy_with_compaction (boost::filesystem::path const & destination_file) +bool nano::node::copy_with_compaction (boost::filesystem::path const & destination_file) { - return !mdb_env_copy2 (boost::polymorphic_downcast (store_impl.get ())->env.environment, destination_file.string ().c_str (), MDB_CP_COMPACT); + return !mdb_env_copy2 (boost::polymorphic_downcast (store_impl.get ())->env.environment, destination_file.string ().c_str (), MDB_CP_COMPACT); } -void rai::node::send_keepalive (rai::endpoint const & endpoint_a) +void nano::node::send_keepalive (nano::endpoint const & endpoint_a) { - network.send_keepalive (rai::map_endpoint_to_v6 (endpoint_a)); + network.send_keepalive (nano::map_endpoint_to_v6 (endpoint_a)); } -void rai::node::process_fork (rai::transaction const & transaction_a, std::shared_ptr block_a) +void nano::node::process_fork (nano::transaction const & transaction_a, std::shared_ptr block_a) { auto root (block_a->root ()); if (!store.block_exists (transaction_a, block_a->type (), block_a->hash ()) && store.root_exists (transaction_a, block_a->root ())) { - std::shared_ptr ledger_block (ledger.forked_block (transaction_a, *block_a)); + std::shared_ptr ledger_block (ledger.forked_block (transaction_a, *block_a)); if (ledger_block) { - std::weak_ptr this_w (shared_from_this ()); - if (!active.start (ledger_block, [this_w, root](std::shared_ptr) { + std::weak_ptr this_w (shared_from_this ()); + if (!active.start (ledger_block, [this_w, root](std::shared_ptr) { if (auto this_l = this_w.lock ()) { auto attempt (this_l->bootstrap_initiator.current_attempt ()); @@ -1882,11 +1882,11 @@ void rai::node::process_fork (rai::transaction const & transaction_a, std::share auto account (this_l->ledger.store.frontier_get (transaction, root)); if (!account.is_zero ()) { - attempt->requeue_pull (rai::pull_info (account, root, root)); + attempt->requeue_pull (nano::pull_info (account, root, root)); } else if (this_l->ledger.store.account_exists (transaction, root)) { - attempt->requeue_pull (rai::pull_info (root, rai::block_hash (0), rai::block_hash (0))); + attempt->requeue_pull (nano::pull_info (root, nano::block_hash (0), nano::block_hash (0))); } } } @@ -1899,25 +1899,25 @@ void rai::node::process_fork (rai::transaction const & transaction_a, std::share } } -rai::gap_cache::gap_cache (rai::node & node_a) : +nano::gap_cache::gap_cache (nano::node & node_a) : node (node_a) { } -void rai::gap_cache::add (rai::transaction const & transaction_a, std::shared_ptr block_a) +void nano::gap_cache::add (nano::transaction const & transaction_a, std::shared_ptr block_a) { auto hash (block_a->hash ()); std::lock_guard lock (mutex); auto existing (blocks.get<1> ().find (hash)); if (existing != blocks.get<1> ().end ()) { - blocks.get<1> ().modify (existing, [](rai::gap_information & info) { + blocks.get<1> ().modify (existing, [](nano::gap_information & info) { info.arrival = std::chrono::steady_clock::now (); }); } else { - blocks.insert ({ std::chrono::steady_clock::now (), hash, std::unordered_set () }); + blocks.insert ({ std::chrono::steady_clock::now (), hash, std::unordered_set () }); if (blocks.size () > max) { blocks.get<0> ().erase (blocks.get<0> ().begin ()); @@ -1925,7 +1925,7 @@ void rai::gap_cache::add (rai::transaction const & transaction_a, std::shared_pt } } -void rai::gap_cache::vote (std::shared_ptr vote_a) +void nano::gap_cache::vote (std::shared_ptr vote_a) { std::lock_guard lock (mutex); auto transaction (node.store.tx_begin_read ()); @@ -1935,7 +1935,7 @@ void rai::gap_cache::vote (std::shared_ptr vote_a) if (existing != blocks.get<1> ().end ()) { auto is_new (false); - blocks.get<1> ().modify (existing, [&](rai::gap_information & info) { is_new = info.voters.insert (vote_a->account).second; }); + blocks.get<1> ().modify (existing, [&](nano::gap_information & info) { is_new = info.voters.insert (vote_a->account).second; }); if (is_new) { uint128_t tally; @@ -1959,7 +1959,7 @@ void rai::gap_cache::vote (std::shared_ptr vote_a) { auto node_l (node.shared ()); auto now (std::chrono::steady_clock::now ()); - node.alarm.add (rai::rai_network == rai::rai_networks::rai_test_network ? now + std::chrono::milliseconds (5) : now + std::chrono::seconds (5), [node_l, hash]() { + node.alarm.add (nano::nano_network == nano::nano_networks::nano_test_network ? now + std::chrono::milliseconds (5) : now + std::chrono::seconds (5), [node_l, hash]() { auto transaction (node_l->store.tx_begin_read ()); if (!node_l->store.block_exists (transaction, hash)) { @@ -1983,19 +1983,19 @@ void rai::gap_cache::vote (std::shared_ptr vote_a) } } -rai::uint128_t rai::gap_cache::bootstrap_threshold (rai::transaction const & transaction_a) +nano::uint128_t nano::gap_cache::bootstrap_threshold (nano::transaction const & transaction_a) { auto result ((node.online_reps.online_stake () / 256) * node.config.bootstrap_fraction_numerator); return result; } -void rai::network::confirm_send (rai::confirm_ack const & confirm_a, std::shared_ptr> bytes_a, rai::endpoint const & endpoint_a) +void nano::network::confirm_send (nano::confirm_ack const & confirm_a, std::shared_ptr> bytes_a, nano::endpoint const & endpoint_a) { if (node.config.logging.network_publish_logging ()) { BOOST_LOG (node.log) << boost::str (boost::format ("Sending confirm_ack for block(s) %1%to %2% sequence %3%") % confirm_a.vote->hashes_string () % endpoint_a % std::to_string (confirm_a.vote->sequence)); } - std::weak_ptr node_w (node.shared ()); + std::weak_ptr node_w (node.shared ()); node.network.send_buffer (bytes_a->data (), bytes_a->size (), endpoint_a, [bytes_a, node_w, endpoint_a](boost::system::error_code const & ec, size_t size_a) { if (auto node_l = node_w.lock ()) { @@ -2005,26 +2005,26 @@ void rai::network::confirm_send (rai::confirm_ack const & confirm_a, std::shared } else { - node_l->stats.inc (rai::stat::type::message, rai::stat::detail::confirm_ack, rai::stat::dir::out); + node_l->stats.inc (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out); } } }); } -void rai::node::process_active (std::shared_ptr incoming) +void nano::node::process_active (std::shared_ptr incoming) { block_arrival.add (incoming->hash ()); block_processor.add (incoming, std::chrono::steady_clock::now ()); } -rai::process_return rai::node::process (rai::block const & block_a) +nano::process_return nano::node::process (nano::block const & block_a) { auto transaction (store.tx_begin_write ()); auto result (ledger.process (transaction, block_a)); return result; } -void rai::node::start () +void nano::node::start () { network.start (); ongoing_keepalive (); @@ -2050,7 +2050,7 @@ void rai::node::start () add_initial_peers (); } -void rai::node::stop () +void nano::node::stop () { BOOST_LOG (log) << "Node stopping"; block_processor.stop (); @@ -2068,52 +2068,52 @@ void rai::node::stop () wallets.stop (); } -void rai::node::keepalive_preconfigured (std::vector const & peers_a) +void nano::node::keepalive_preconfigured (std::vector const & peers_a) { for (auto i (peers_a.begin ()), n (peers_a.end ()); i != n; ++i) { - keepalive (*i, rai::network::node_port); + keepalive (*i, nano::network::node_port); } } -rai::block_hash rai::node::latest (rai::account const & account_a) +nano::block_hash nano::node::latest (nano::account const & account_a) { auto transaction (store.tx_begin_read ()); return ledger.latest (transaction, account_a); } -rai::uint128_t rai::node::balance (rai::account const & account_a) +nano::uint128_t nano::node::balance (nano::account const & account_a) { auto transaction (store.tx_begin_read ()); return ledger.account_balance (transaction, account_a); } -std::shared_ptr rai::node::block (rai::block_hash const & hash_a) +std::shared_ptr nano::node::block (nano::block_hash const & hash_a) { auto transaction (store.tx_begin_read ()); return store.block_get (transaction, hash_a); } -std::pair rai::node::balance_pending (rai::account const & account_a) +std::pair nano::node::balance_pending (nano::account const & account_a) { - std::pair result; + std::pair result; auto transaction (store.tx_begin_read ()); result.first = ledger.account_balance (transaction, account_a); result.second = ledger.account_pending (transaction, account_a); return result; } -rai::uint128_t rai::node::weight (rai::account const & account_a) +nano::uint128_t nano::node::weight (nano::account const & account_a) { auto transaction (store.tx_begin_read ()); return ledger.weight (transaction, account_a); } -rai::account rai::node::representative (rai::account const & account_a) +nano::account nano::node::representative (nano::account const & account_a) { auto transaction (store.tx_begin_read ()); - rai::account_info info; - rai::account result (0); + nano::account_info info; + nano::account result (0); if (!store.account_get (transaction, account_a, info)) { result = info.rep_block; @@ -2121,7 +2121,7 @@ rai::account rai::node::representative (rai::account const & account_a) return result; } -void rai::node::ongoing_keepalive () +void nano::node::ongoing_keepalive () { keepalive_preconfigured (config.preconfigured_peers); auto peers_l (peers.purge_list (std::chrono::steady_clock::now () - cutoff)); @@ -2129,7 +2129,7 @@ void rai::node::ongoing_keepalive () { network.send_keepalive (i->endpoint); } - std::weak_ptr node_w (shared_from_this ()); + std::weak_ptr node_w (shared_from_this ()); alarm.add (std::chrono::steady_clock::now () + period, [node_w]() { if (auto node_l = node_w.lock ()) { @@ -2138,10 +2138,10 @@ void rai::node::ongoing_keepalive () }); } -void rai::node::ongoing_syn_cookie_cleanup () +void nano::node::ongoing_syn_cookie_cleanup () { peers.purge_syn_cookies (std::chrono::steady_clock::now () - syn_cookie_cutoff); - std::weak_ptr node_w (shared_from_this ()); + std::weak_ptr node_w (shared_from_this ()); alarm.add (std::chrono::steady_clock::now () + (syn_cookie_cutoff * 2), [node_w]() { if (auto node_l = node_w.lock ()) { @@ -2150,14 +2150,14 @@ void rai::node::ongoing_syn_cookie_cleanup () }); } -void rai::node::ongoing_rep_crawl () +void nano::node::ongoing_rep_crawl () { auto now (std::chrono::steady_clock::now ()); auto peers_l (peers.rep_crawl ()); rep_query (*this, peers_l); if (network.on) { - std::weak_ptr node_w (shared_from_this ()); + std::weak_ptr node_w (shared_from_this ()); alarm.add (now + std::chrono::seconds (4), [node_w]() { if (auto node_l = node_w.lock ()) { @@ -2167,11 +2167,11 @@ void rai::node::ongoing_rep_crawl () } } -void rai::node::ongoing_rep_calculation () +void nano::node::ongoing_rep_calculation () { auto now (std::chrono::steady_clock::now ()); vote_processor.calculate_weights (); - std::weak_ptr node_w (shared_from_this ()); + std::weak_ptr node_w (shared_from_this ()); alarm.add (now + std::chrono::minutes (10), [node_w]() { if (auto node_l = node_w.lock ()) { @@ -2180,7 +2180,7 @@ void rai::node::ongoing_rep_calculation () }); } -void rai::node::ongoing_bootstrap () +void nano::node::ongoing_bootstrap () { auto next_wakeup (300); if (warmed_up < 3) @@ -2193,7 +2193,7 @@ void rai::node::ongoing_bootstrap () } } bootstrap_initiator.bootstrap (); - std::weak_ptr node_w (shared_from_this ()); + std::weak_ptr node_w (shared_from_this ()); alarm.add (std::chrono::steady_clock::now () + std::chrono::seconds (next_wakeup), [node_w]() { if (auto node_l = node_w.lock ()) { @@ -2202,13 +2202,13 @@ void rai::node::ongoing_bootstrap () }); } -void rai::node::ongoing_store_flush () +void nano::node::ongoing_store_flush () { { auto transaction (store.tx_begin_write ()); store.flush (transaction); } - std::weak_ptr node_w (shared_from_this ()); + std::weak_ptr node_w (shared_from_this ()); alarm.add (std::chrono::steady_clock::now () + std::chrono::seconds (5), [node_w]() { if (auto node_l = node_w.lock ()) { @@ -2217,7 +2217,7 @@ void rai::node::ongoing_store_flush () }); } -void rai::node::backup_wallet () +void nano::node::backup_wallet () { auto transaction (store.tx_begin_read ()); for (auto i (wallets.items.begin ()), n (wallets.items.end ()); i != n; ++i) @@ -2226,7 +2226,7 @@ void rai::node::backup_wallet () auto backup_path (application_path / "backup"); boost::filesystem::create_directories (backup_path); - rai::set_secure_perm_directory (backup_path, error_chmod); + nano::set_secure_perm_directory (backup_path, error_chmod); i->second->store.write_backup (transaction, backup_path / (i->first.to_string () + ".json")); } auto this_l (shared ()); @@ -2235,7 +2235,7 @@ void rai::node::backup_wallet () }); } -void rai::node::search_pending () +void nano::node::search_pending () { wallets.search_pending_all (); auto this_l (shared ()); @@ -2244,15 +2244,15 @@ void rai::node::search_pending () }); } -int rai::node::price (rai::uint128_t const & balance_a, int amount_a) +int nano::node::price (nano::uint128_t const & balance_a, int amount_a) { - assert (balance_a >= amount_a * rai::Gxrb_ratio); + assert (balance_a >= amount_a * nano::Gxrb_ratio); auto balance_l (balance_a); double result (0.0); for (auto i (0); i < amount_a; ++i) { - balance_l -= rai::Gxrb_ratio; - auto balance_scaled ((balance_l / rai::Mxrb_ratio).convert_to ()); + balance_l -= nano::Gxrb_ratio; + auto balance_scaled ((balance_l / nano::Mxrb_ratio).convert_to ()); auto units (balance_scaled / 1000.0); auto unit_price (((free_cutoff - units) / free_cutoff) * price_max); result += std::min (std::max (0.0, unit_price), price_max); @@ -2280,12 +2280,12 @@ public: class distributed_work : public std::enable_shared_from_this { public: - distributed_work (std::shared_ptr const & node_a, rai::block_hash const & root_a, std::function callback_a, uint64_t difficulty_a) : + distributed_work (std::shared_ptr const & node_a, nano::block_hash const & root_a, std::function callback_a, uint64_t difficulty_a) : distributed_work (1, node_a, root_a, callback_a, difficulty_a) { assert (node_a != nullptr); } - distributed_work (unsigned int backoff_a, std::shared_ptr const & node_a, rai::block_hash const & root_a, std::function callback_a, uint64_t difficulty_a) : + distributed_work (unsigned int backoff_a, std::shared_ptr const & node_a, nano::block_hash const & root_a, std::function callback_a, uint64_t difficulty_a) : callback (callback_a), backoff (backoff_a), node (node_a), @@ -2346,7 +2346,7 @@ public: auto service (i.second); node->background ([this_l, host, service]() { auto connection (std::make_shared (this_l->node->io_ctx, host, service)); - connection->socket.async_connect (rai::tcp_endpoint (host, service), [this_l, connection](boost::system::error_code const & ec) { + connection->socket.async_connect (nano::tcp_endpoint (host, service), [this_l, connection](boost::system::error_code const & ec) { if (!ec) { std::string request_string; @@ -2448,9 +2448,9 @@ public: boost::property_tree::read_json (istream, result); auto work_text (result.get ("work")); uint64_t work; - if (!rai::from_string_hex (work_text, work)) + if (!nano::from_string_hex (work_text, work)) { - if (!rai::work_validate (root, work)) + if (!nano::work_validate (root, work)) { set_once (work); stop (); @@ -2508,9 +2508,9 @@ public: auto now (std::chrono::steady_clock::now ()); auto root_l (root); auto callback_l (callback); - std::weak_ptr node_w (node); + std::weak_ptr node_w (node); auto next_backoff (std::min (backoff * 2, (unsigned int)60 * 5)); - node->alarm.add (now + std::chrono::seconds (backoff), [ node_w, root_l, callback_l, next_backoff, difficulty = difficulty ] { + node->alarm.add (now + std::chrono::seconds (backoff), [node_w, root_l, callback_l, next_backoff, difficulty = difficulty] { if (auto node_l = node_w.lock ()) { auto work_generation (std::make_shared (next_backoff, node_l, root_l, callback_l, difficulty)); @@ -2529,8 +2529,8 @@ public: } std::function callback; unsigned int backoff; // in seconds - std::shared_ptr node; - rai::block_hash root; + std::shared_ptr node; + nano::block_hash root; std::mutex mutex; std::map outstanding; std::vector> need_resolve; @@ -2539,18 +2539,18 @@ public: }; } -void rai::node::work_generate_blocking (rai::block & block_a, uint64_t difficulty_a) +void nano::node::work_generate_blocking (nano::block & block_a, uint64_t difficulty_a) { block_a.block_work_set (work_generate_blocking (block_a.root (), difficulty_a)); } -void rai::node::work_generate (rai::uint256_union const & hash_a, std::function callback_a, uint64_t difficulty_a) +void nano::node::work_generate (nano::uint256_union const & hash_a, std::function callback_a, uint64_t difficulty_a) { auto work_generation (std::make_shared (shared (), hash_a, callback_a, difficulty_a)); work_generation->start (); } -uint64_t rai::node::work_generate_blocking (rai::uint256_union const & hash_a, uint64_t difficulty_a) +uint64_t nano::node::work_generate_blocking (nano::uint256_union const & hash_a, uint64_t difficulty_a) { std::promise promise; work_generate (hash_a, [&promise](uint64_t work_a) { @@ -2560,17 +2560,17 @@ uint64_t rai::node::work_generate_blocking (rai::uint256_union const & hash_a, u return promise.get_future ().get (); } -void rai::node::add_initial_peers () +void nano::node::add_initial_peers () { } -void rai::node::block_confirm (std::shared_ptr block_a) +void nano::node::block_confirm (std::shared_ptr block_a) { active.start (block_a); network.broadcast_confirm_req (block_a); } -rai::uint128_t rai::node::delta () +nano::uint128_t nano::node::delta () { auto result ((online_reps.online_stake () / 100) * config.online_weight_quorum); return result; @@ -2578,10 +2578,10 @@ rai::uint128_t rai::node::delta () namespace { -class confirmed_visitor : public rai::block_visitor +class confirmed_visitor : public nano::block_visitor { public: - confirmed_visitor (rai::transaction const & transaction_a, rai::node & node_a, std::shared_ptr block_a, rai::block_hash const & hash_a) : + confirmed_visitor (nano::transaction const & transaction_a, nano::node & node_a, std::shared_ptr block_a, nano::block_hash const & hash_a) : transaction (transaction_a), node (node_a), block (block_a), @@ -2589,22 +2589,22 @@ public: { } virtual ~confirmed_visitor () = default; - void scan_receivable (rai::account const & account_a) + void scan_receivable (nano::account const & account_a) { for (auto i (node.wallets.items.begin ()), n (node.wallets.items.end ()); i != n; ++i) { auto wallet (i->second); if (wallet->store.exists (transaction, account_a)) { - rai::account representative; - rai::pending_info pending; + nano::account representative; + nano::pending_info pending; representative = wallet->store.representative (transaction); - auto error (node.store.pending_get (transaction, rai::pending_key (account_a, hash), pending)); + auto error (node.store.pending_get (transaction, nano::pending_key (account_a, hash), pending)); if (!error) { auto node_l (node.shared ()); auto amount (pending.amount.number ()); - wallet->receive_async (block, representative, amount, [](std::shared_ptr) {}); + wallet->receive_async (block, representative, amount, [](std::shared_ptr) {}); } else { @@ -2621,31 +2621,31 @@ public: } } } - void state_block (rai::state_block const & block_a) override + void state_block (nano::state_block const & block_a) override { scan_receivable (block_a.hashables.link); } - void send_block (rai::send_block const & block_a) override + void send_block (nano::send_block const & block_a) override { scan_receivable (block_a.hashables.destination); } - void receive_block (rai::receive_block const &) override + void receive_block (nano::receive_block const &) override { } - void open_block (rai::open_block const &) override + void open_block (nano::open_block const &) override { } - void change_block (rai::change_block const &) override + void change_block (nano::change_block const &) override { } - rai::transaction const & transaction; - rai::node & node; - std::shared_ptr block; - rai::block_hash const & hash; + nano::transaction const & transaction; + nano::node & node; + std::shared_ptr block; + nano::block_hash const & hash; }; } -void rai::node::process_confirmed (std::shared_ptr block_a) +void nano::node::process_confirmed (std::shared_ptr block_a) { auto hash (block_a->hash ()); bool exists (ledger.block_exists (block_a->type (), hash)); @@ -2664,13 +2664,13 @@ void rai::node::process_confirmed (std::shared_ptr block_a) auto account (ledger.account (transaction, hash)); auto amount (ledger.amount (transaction, hash)); bool is_state_send (false); - rai::account pending_account (0); - if (auto state = dynamic_cast (block_a.get ())) + nano::account pending_account (0); + if (auto state = dynamic_cast (block_a.get ())) { is_state_send = ledger.is_send (transaction, *state); pending_account = state->hashables.link; } - if (auto send = dynamic_cast (block_a.get ())) + if (auto send = dynamic_cast (block_a.get ())) { pending_account = send->hashables.destination; } @@ -2686,13 +2686,13 @@ void rai::node::process_confirmed (std::shared_ptr block_a) } } -void rai::node::process_message (rai::message & message_a, rai::endpoint const & sender_a) +void nano::node::process_message (nano::message & message_a, nano::endpoint const & sender_a) { network_message_visitor visitor (*this, sender_a); message_a.visit (visitor); } -rai::endpoint rai::network::endpoint () +nano::endpoint nano::network::endpoint () { boost::system::error_code ec; auto port (socket.local_endpoint (ec).port ()); @@ -2700,19 +2700,19 @@ rai::endpoint rai::network::endpoint () { BOOST_LOG (node.log) << "Unable to retrieve port: " << ec.message (); } - return rai::endpoint (boost::asio::ip::address_v6::loopback (), port); + return nano::endpoint (boost::asio::ip::address_v6::loopback (), port); } -bool rai::block_arrival::add (rai::block_hash const & hash_a) +bool nano::block_arrival::add (nano::block_hash const & hash_a) { std::lock_guard lock (mutex); auto now (std::chrono::steady_clock::now ()); - auto inserted (arrival.insert (rai::block_arrival_info{ now, hash_a })); + auto inserted (arrival.insert (nano::block_arrival_info{ now, hash_a })); auto result (!inserted.second); return result; } -bool rai::block_arrival::recent (rai::block_hash const & hash_a) +bool nano::block_arrival::recent (nano::block_hash const & hash_a) { std::lock_guard lock (mutex); auto now (std::chrono::steady_clock::now ()); @@ -2723,19 +2723,19 @@ bool rai::block_arrival::recent (rai::block_hash const & hash_a) return arrival.get<1> ().find (hash_a) != arrival.get<1> ().end (); } -rai::online_reps::online_reps (rai::node & node) : +nano::online_reps::online_reps (nano::node & node) : node (node) { } -void rai::online_reps::vote (std::shared_ptr const & vote_a) +void nano::online_reps::vote (std::shared_ptr const & vote_a) { auto rep (vote_a->account); std::lock_guard lock (mutex); auto now (std::chrono::steady_clock::now ()); auto transaction (node.store.tx_begin_read ()); auto current (reps.begin ()); - while (current != reps.end () && current->last_heard + std::chrono::seconds (rai::node::cutoff) < now) + while (current != reps.end () && current->last_heard + std::chrono::seconds (nano::node::cutoff) < now) { auto old_stake (online_stake_total); online_stake_total -= node.ledger.weight (transaction, current->representative); @@ -2747,7 +2747,7 @@ void rai::online_reps::vote (std::shared_ptr const & vote_a) current = reps.erase (current); } auto rep_it (reps.get<1> ().find (rep)); - auto info (rai::rep_last_heard_info{ now, rep }); + auto info (nano::rep_last_heard_info{ now, rep }); if (rep_it == reps.get<1> ().end ()) { auto old_stake (online_stake_total); @@ -2755,7 +2755,7 @@ void rai::online_reps::vote (std::shared_ptr const & vote_a) if (online_stake_total < old_stake) { // overflow - online_stake_total = std::numeric_limits::max (); + online_stake_total = std::numeric_limits::max (); } reps.insert (info); } @@ -2765,7 +2765,7 @@ void rai::online_reps::vote (std::shared_ptr const & vote_a) } } -void rai::online_reps::recalculate_stake () +void nano::online_reps::recalculate_stake () { std::lock_guard lock (mutex); online_stake_total = 0; @@ -2775,7 +2775,7 @@ void rai::online_reps::recalculate_stake () online_stake_total += node.ledger.weight (transaction, it.representative); } auto now (std::chrono::steady_clock::now ()); - std::weak_ptr node_w (node.shared ()); + std::weak_ptr node_w (node.shared ()); node.alarm.add (now + std::chrono::minutes (5), [node_w]() { if (auto node_l = node_w.lock ()) { @@ -2784,15 +2784,15 @@ void rai::online_reps::recalculate_stake () }); } -rai::uint128_t rai::online_reps::online_stake () +nano::uint128_t nano::online_reps::online_stake () { std::lock_guard lock (mutex); return std::max (online_stake_total, node.config.online_weight_minimum.number ()); } -std::vector rai::online_reps::list () +std::vector nano::online_reps::list () { - std::vector result; + std::vector result; std::lock_guard lock (mutex); for (auto i (reps.begin ()), n (reps.end ()); i != n; ++i) { @@ -2809,7 +2809,7 @@ boost::asio::ip::address_v6 mapped_from_v4_bytes (unsigned long address_a) } } -bool rai::reserved_address (rai::endpoint const & endpoint_a, bool blacklist_loopback) +bool nano::reserved_address (nano::endpoint const & endpoint_a, bool blacklist_loopback) { assert (endpoint_a.address ().is_v6 ()); auto bytes (endpoint_a.address ().to_v6 ()); @@ -2888,7 +2888,7 @@ bool rai::reserved_address (rai::endpoint const & endpoint_a, bool blacklist_loo { result = true; } - else if (rai::rai_network == rai::rai_networks::rai_live_network) + else if (nano::nano_network == nano::nano_networks::nano_live_network) { if (bytes >= rfc1918_1_min && bytes <= rfc1918_1_max) { @@ -2914,7 +2914,7 @@ bool rai::reserved_address (rai::endpoint const & endpoint_a, bool blacklist_loo return result; } -void rai::network::send_buffer (uint8_t const * data_a, size_t size_a, rai::endpoint const & endpoint_a, std::function callback_a) +void nano::network::send_buffer (uint8_t const * data_a, size_t size_a, nano::endpoint const & endpoint_a, std::function callback_a) { std::unique_lock lock (socket_mutex); if (node.config.logging.network_packet_logging ()) @@ -2923,10 +2923,10 @@ void rai::network::send_buffer (uint8_t const * data_a, size_t size_a, rai::endp } socket.async_send_to (boost::asio::buffer (data_a, size_a), endpoint_a, [this, callback_a](boost::system::error_code const & ec, size_t size_a) { callback_a (ec, size_a); - this->node.stats.add (rai::stat::type::traffic, rai::stat::dir::out, size_a); + this->node.stats.add (nano::stat::type::traffic, nano::stat::dir::out, size_a); if (ec == boost::system::errc::host_unreachable) { - this->node.stats.inc (rai::stat::type::error, rai::stat::detail::unreachable_host, rai::stat::dir::out); + this->node.stats.inc (nano::stat::type::error, nano::stat::detail::unreachable_host, nano::stat::dir::out); } if (this->node.config.logging.network_packet_logging ()) { @@ -2935,24 +2935,24 @@ void rai::network::send_buffer (uint8_t const * data_a, size_t size_a, rai::endp }); } -std::shared_ptr rai::node::shared () +std::shared_ptr nano::node::shared () { return shared_from_this (); } -rai::election_vote_result::election_vote_result () : +nano::election_vote_result::election_vote_result () : replay (false), processed (false) { } -rai::election_vote_result::election_vote_result (bool replay_a, bool processed_a) +nano::election_vote_result::election_vote_result (bool replay_a, bool processed_a) { replay = replay_a; processed = processed_a; } -rai::election::election (rai::node & node_a, std::shared_ptr block_a, std::function)> const & confirmation_action_a) : +nano::election::election (nano::node & node_a, std::shared_ptr block_a, std::function)> const & confirmation_action_a) : confirmation_action (confirmation_action_a), node (node_a), root (block_a->root ()), @@ -2962,22 +2962,22 @@ confirmed (false), stopped (false), announcements (0) { - last_votes.insert (std::make_pair (rai::not_an_account, rai::vote_info{ std::chrono::steady_clock::now (), 0, block_a->hash () })); + last_votes.insert (std::make_pair (nano::not_an_account, nano::vote_info{ std::chrono::steady_clock::now (), 0, block_a->hash () })); blocks.insert (std::make_pair (block_a->hash (), block_a)); } -void rai::election::compute_rep_votes (rai::transaction const & transaction_a) +void nano::election::compute_rep_votes (nano::transaction const & transaction_a) { if (node.config.enable_voting) { - node.wallets.foreach_representative (transaction_a, [this, &transaction_a](rai::public_key const & pub_a, rai::raw_key const & prv_a) { + node.wallets.foreach_representative (transaction_a, [this, &transaction_a](nano::public_key const & pub_a, nano::raw_key const & prv_a) { auto vote (this->node.store.vote_generate (transaction_a, pub_a, prv_a, status.winner)); this->node.vote_processor.vote (vote, this->node.network.endpoint ()); }); } } -void rai::election::confirm_once (rai::transaction const & transaction_a) +void nano::election::confirm_once (nano::transaction const & transaction_a) { if (!confirmed.exchange (true)) { @@ -2994,9 +2994,9 @@ void rai::election::confirm_once (rai::transaction const & transaction_a) } } -void rai::election::confirm_back (rai::transaction const & transaction_a) +void nano::election::confirm_back (nano::transaction const & transaction_a) { - std::vector hashes = { status.winner->previous (), status.winner->source (), status.winner->link () }; + std::vector hashes = { status.winner->previous (), status.winner->source (), status.winner->link () }; for (auto & hash : hashes) { if (!hash.is_zero () && !node.ledger.is_epoch_link (hash)) @@ -3010,12 +3010,12 @@ void rai::election::confirm_back (rai::transaction const & transaction_a) } } -void rai::election::stop () +void nano::election::stop () { stopped = true; } -bool rai::election::have_quorum (rai::tally_t const & tally_a, rai::uint128_t tally_sum) +bool nano::election::have_quorum (nano::tally_t const & tally_a, nano::uint128_t tally_sum) { bool result = false; if (tally_sum >= node.config.online_weight_minimum.number ()) @@ -3030,15 +3030,15 @@ bool rai::election::have_quorum (rai::tally_t const & tally_a, rai::uint128_t ta return result; } -rai::tally_t rai::election::tally (rai::transaction const & transaction_a) +nano::tally_t nano::election::tally (nano::transaction const & transaction_a) { - std::unordered_map block_weights; + std::unordered_map block_weights; for (auto vote_info : last_votes) { block_weights[vote_info.second.hash] += node.ledger.weight (transaction_a, vote_info.first); } last_tally = block_weights; - rai::tally_t result; + nano::tally_t result; for (auto item : block_weights) { auto block (blocks.find (item.first)); @@ -3050,14 +3050,14 @@ rai::tally_t rai::election::tally (rai::transaction const & transaction_a) return result; } -void rai::election::confirm_if_quorum (rai::transaction const & transaction_a) +void nano::election::confirm_if_quorum (nano::transaction const & transaction_a) { auto tally_l (tally (transaction_a)); assert (tally_l.size () > 0); auto winner (tally_l.begin ()); auto block_l (winner->second); status.tally = winner->first; - rai::uint128_t sum (0); + nano::uint128_t sum (0); for (auto & i : tally_l) { sum += i.first; @@ -3078,7 +3078,7 @@ void rai::election::confirm_if_quorum (rai::transaction const & transaction_a) } } -void rai::election::log_votes (rai::tally_t const & tally_a) +void nano::election::log_votes (nano::tally_t const & tally_a) { std::stringstream tally; tally << boost::str (boost::format ("\nVote tally for root %1%") % status.winner->root ().to_string ()); @@ -3093,7 +3093,7 @@ void rai::election::log_votes (rai::tally_t const & tally_a) BOOST_LOG (node.log) << tally.str (); } -rai::election_vote_result rai::election::vote (rai::account rep, uint64_t sequence, rai::block_hash block_hash) +nano::election_vote_result nano::election::vote (nano::account rep, uint64_t sequence, nano::block_hash block_hash) { // see republish_vote documentation for an explanation of these rules auto transaction (node.store.tx_begin_read ()); @@ -3101,7 +3101,7 @@ rai::election_vote_result rai::election::vote (rai::account rep, uint64_t sequen auto supply (node.online_reps.online_stake ()); auto weight (node.ledger.weight (transaction, rep)); auto should_process (false); - if (rai::rai_network == rai::rai_networks::rai_test_network || weight > supply / 1000) // 0.1% or above + if (nano::nano_network == nano::nano_networks::nano_test_network || weight > supply / 1000) // 0.1% or above { unsigned int cooldown; if (weight < supply / 100) // 0.1% to 1% @@ -3145,13 +3145,13 @@ rai::election_vote_result rai::election::vote (rai::account rep, uint64_t sequen } } } - return rai::election_vote_result (replay, should_process); + return nano::election_vote_result (replay, should_process); } -bool rai::node::validate_block_by_previous (rai::transaction const & transaction, std::shared_ptr block_a) +bool nano::node::validate_block_by_previous (nano::transaction const & transaction, std::shared_ptr block_a) { bool result (false); - rai::account account; + nano::account account; if (!block_a->previous ().is_zero ()) { if (store.block_exists (transaction, block_a->previous ())) @@ -3167,10 +3167,10 @@ bool rai::node::validate_block_by_previous (rai::transaction const & transaction { account = block_a->root (); } - if (!result && block_a->type () == rai::block_type::state) + if (!result && block_a->type () == nano::block_type::state) { - std::shared_ptr block_l (std::static_pointer_cast (block_a)); - rai::amount prev_balance (0); + std::shared_ptr block_l (std::static_pointer_cast (block_a)); + nano::amount prev_balance (0); if (!block_l->hashables.previous.is_zero ()) { if (store.block_exists (transaction, block_l->hashables.previous)) @@ -3190,14 +3190,14 @@ bool rai::node::validate_block_by_previous (rai::transaction const & transaction } } } - if (!result && (account.is_zero () || rai::validate_message (account, block_a->hash (), block_a->block_signature ()))) + if (!result && (account.is_zero () || nano::validate_message (account, block_a->hash (), block_a->block_signature ()))) { result = true; } return result; } -bool rai::election::publish (std::shared_ptr block_a) +bool nano::election::publish (std::shared_ptr block_a) { auto result (false); if (blocks.size () >= 10) @@ -3224,14 +3224,14 @@ bool rai::election::publish (std::shared_ptr block_a) return result; } -void rai::active_transactions::announce_votes (std::unique_lock & lock_a) +void nano::active_transactions::announce_votes (std::unique_lock & lock_a) { - std::unordered_set inactive; + std::unordered_set inactive; auto transaction (node.store.tx_begin_read ()); unsigned unconfirmed_count (0); unsigned unconfirmed_announcements (0); - std::deque> rebroadcast_bundle; - std::deque, std::shared_ptr>>> confirm_req_bundle; + std::deque> rebroadcast_bundle; + std::deque, std::shared_ptr>>> confirm_req_bundle; auto roots_size (roots.size ()); for (auto i (roots.get<1> ().begin ()), n (roots.get<1> ().end ()); i != n; ++i) @@ -3265,9 +3265,9 @@ void rai::active_transactions::announce_votes (std::unique_lock & lo /* Escalation for long unconfirmed elections Start new elections for previous block & source if there are less than 100 active elections */ - if (i->election->announcements % announcement_long == 1 && roots_size < 100 && rai::rai_network != rai::rai_networks::rai_test_network) + if (i->election->announcements % announcement_long == 1 && roots_size < 100 && nano::nano_network != nano::nano_networks::nano_test_network) { - std::shared_ptr previous; + std::shared_ptr previous; auto previous_hash (election_l->status.winner->previous ()); if (!previous_hash.is_zero ()) { @@ -3313,9 +3313,9 @@ void rai::active_transactions::announce_votes (std::unique_lock & lo } if (i->election->announcements % 4 == 1) { - auto reps (std::make_shared> (node.peers.representatives (std::numeric_limits::max ()))); - std::unordered_set probable_reps; - rai::uint128_t total_weight (0); + auto reps (std::make_shared> (node.peers.representatives (std::numeric_limits::max ()))); + std::unordered_set probable_reps; + nano::uint128_t total_weight (0); for (auto j (reps->begin ()), m (reps->end ()); j != m;) { auto & rep_votes (i->election->last_votes); @@ -3357,7 +3357,7 @@ void rai::active_transactions::announce_votes (std::unique_lock & lo else { // broadcast request to all peers - confirm_req_bundle.push_back (std::make_pair (i->election->status.winner, std::make_shared> (node.peers.list_vector (100)))); + confirm_req_bundle.push_back (std::make_pair (i->election->status.winner, std::make_shared> (node.peers.list_vector (100)))); } } } @@ -3392,7 +3392,7 @@ void rai::active_transactions::announce_votes (std::unique_lock & lo } } -void rai::active_transactions::announce_loop () +void nano::active_transactions::announce_loop () { std::unique_lock lock (mutex); started = true; @@ -3409,7 +3409,7 @@ void rai::active_transactions::announce_loop () } } -void rai::active_transactions::stop () +void nano::active_transactions::stop () { std::unique_lock lock (mutex); while (!started) @@ -3427,13 +3427,13 @@ void rai::active_transactions::stop () roots.clear (); } -bool rai::active_transactions::start (std::shared_ptr block_a, std::function)> const & confirmation_action_a) +bool nano::active_transactions::start (std::shared_ptr block_a, std::function)> const & confirmation_action_a) { std::lock_guard lock (mutex); return add (block_a, confirmation_action_a); } -bool rai::active_transactions::add (std::shared_ptr block_a, std::function)> const & confirmation_action_a) +bool nano::active_transactions::add (std::shared_ptr block_a, std::function)> const & confirmation_action_a) { auto error (true); if (!stopped) @@ -3442,11 +3442,11 @@ bool rai::active_transactions::add (std::shared_ptr block_a, std::fu auto existing (roots.find (root)); if (existing == roots.end ()) { - auto election (std::make_shared (node, block_a, confirmation_action_a)); + auto election (std::make_shared (node, block_a, confirmation_action_a)); uint64_t difficulty (0); - auto error (rai::work_validate (*block_a, &difficulty)); + auto error (nano::work_validate (*block_a, &difficulty)); release_assert (!error); - roots.insert (rai::conflict_info{ root, difficulty, election }); + roots.insert (nano::conflict_info{ root, difficulty, election }); blocks.insert (std::make_pair (block_a->hash (), election)); } error = existing != roots.end (); @@ -3455,9 +3455,9 @@ bool rai::active_transactions::add (std::shared_ptr block_a, std::fu } // Validate a vote and apply it to the current election if one exists -bool rai::active_transactions::vote (std::shared_ptr vote_a, bool single_lock) +bool nano::active_transactions::vote (std::shared_ptr vote_a, bool single_lock) { - std::shared_ptr election; + std::shared_ptr election; bool replay (false); bool processed (false); { @@ -3468,10 +3468,10 @@ bool rai::active_transactions::vote (std::shared_ptr vote_a, bool sin } for (auto vote_block : vote_a->blocks) { - rai::election_vote_result result; + nano::election_vote_result result; if (vote_block.which ()) { - auto block_hash (boost::get (vote_block)); + auto block_hash (boost::get (vote_block)); auto existing (blocks.find (block_hash)); if (existing != blocks.end ()) { @@ -3480,7 +3480,7 @@ bool rai::active_transactions::vote (std::shared_ptr vote_a, bool sin } else { - auto block (boost::get> (vote_block)); + auto block (boost::get> (vote_block)); auto existing (roots.find (block->root ())); if (existing != roots.end ()) { @@ -3498,31 +3498,31 @@ bool rai::active_transactions::vote (std::shared_ptr vote_a, bool sin return replay; } -bool rai::active_transactions::active (rai::block const & block_a) +bool nano::active_transactions::active (nano::block const & block_a) { std::lock_guard lock (mutex); return roots.find (block_a.root ()) != roots.end (); } -void rai::active_transactions::update_difficulty (rai::block const & block_a) +void nano::active_transactions::update_difficulty (nano::block const & block_a) { std::lock_guard lock (mutex); auto existing (roots.find (block_a.root ())); if (existing != roots.end ()) { uint64_t difficulty; - auto error (rai::work_validate (block_a, &difficulty)); + auto error (nano::work_validate (block_a, &difficulty)); assert (!error); - roots.modify (existing, [difficulty](rai::conflict_info & info_a) { + roots.modify (existing, [difficulty](nano::conflict_info & info_a) { info_a.difficulty = difficulty; }); } } // List of active blocks in elections -std::deque> rai::active_transactions::list_blocks (bool single_lock) +std::deque> nano::active_transactions::list_blocks (bool single_lock) { - std::deque> result; + std::deque> result; std::unique_lock lock; if (!single_lock) { @@ -3535,7 +3535,7 @@ std::deque> rai::active_transactions::list_blocks (b return result; } -void rai::active_transactions::erase (rai::block const & block_a) +void nano::active_transactions::erase (nano::block const & block_a) { std::lock_guard lock (mutex); if (roots.find (block_a.root ()) != roots.end ()) @@ -3545,12 +3545,12 @@ void rai::active_transactions::erase (rai::block const & block_a) } } -rai::active_transactions::active_transactions (rai::node & node_a) : +nano::active_transactions::active_transactions (nano::node & node_a) : node (node_a), started (false), stopped (false), thread ([this]() { - rai::thread_role::set (rai::thread_role::name::announce_loop); + nano::thread_role::set (nano::thread_role::name::announce_loop); announce_loop (); }) { @@ -3561,12 +3561,12 @@ thread ([this]() { } } -rai::active_transactions::~active_transactions () +nano::active_transactions::~active_transactions () { stop (); } -bool rai::active_transactions::publish (std::shared_ptr block_a) +bool nano::active_transactions::publish (std::shared_ptr block_a) { std::lock_guard lock (mutex); auto existing (roots.find (block_a->root ())); @@ -3582,20 +3582,20 @@ bool rai::active_transactions::publish (std::shared_ptr block_a) return result; } -int rai::node::store_version () +int nano::node::store_version () { auto transaction (store.tx_begin_read ()); return store.version_get (transaction); } -rai::thread_runner::thread_runner (boost::asio::io_context & io_ctx_a, unsigned service_threads_a) +nano::thread_runner::thread_runner (boost::asio::io_context & io_ctx_a, unsigned service_threads_a) { boost::thread::attributes attrs; - rai::thread_attributes::set (attrs); + nano::thread_attributes::set (attrs); for (auto i (0); i < service_threads_a; ++i) { threads.push_back (boost::thread (attrs, [&io_ctx_a]() { - rai::thread_role::set (rai::thread_role::name::io); + nano::thread_role::set (nano::thread_role::name::io); try { io_ctx_a.run (); @@ -3615,12 +3615,12 @@ rai::thread_runner::thread_runner (boost::asio::io_context & io_ctx_a, unsigned } } -rai::thread_runner::~thread_runner () +nano::thread_runner::~thread_runner () { join (); } -void rai::thread_runner::join () +void nano::thread_runner::join () { for (auto & i : threads) { @@ -3631,7 +3631,7 @@ void rai::thread_runner::join () } } -rai::inactive_node::inactive_node (boost::filesystem::path const & path, uint16_t peering_port_a) : +nano::inactive_node::inactive_node (boost::filesystem::path const & path, uint16_t peering_port_a) : path (path), io_context (std::make_shared ()), alarm (*io_context), @@ -3644,18 +3644,18 @@ peering_port (peering_port_a) * @warning May throw a filesystem exception */ boost::filesystem::create_directories (path); - rai::set_secure_perm_directory (path, error_chmod); + nano::set_secure_perm_directory (path, error_chmod); logging.max_size = std::numeric_limits::max (); logging.init (path); - node = std::make_shared (init, *io_context, peering_port, path, alarm, logging, work); + node = std::make_shared (init, *io_context, peering_port, path, alarm, logging, work); } -rai::inactive_node::~inactive_node () +nano::inactive_node::~inactive_node () { node->stop (); } -rai::udp_buffer::udp_buffer (rai::stat & stats, size_t size, size_t count) : +nano::udp_buffer::udp_buffer (nano::stat & stats, size_t size, size_t count) : stats (stats), free (count), full (count), @@ -3669,19 +3669,19 @@ stopped (false) auto entry_data (entries.data ()); for (auto i (0); i < count; ++i, ++entry_data) { - *entry_data = { slab_data + i * size, 0, rai::endpoint () }; + *entry_data = { slab_data + i * size, 0, nano::endpoint () }; free.push_back (entry_data); } } -rai::udp_data * rai::udp_buffer::allocate () +nano::udp_data * nano::udp_buffer::allocate () { std::unique_lock lock (mutex); while (!stopped && free.empty () && full.empty ()) { - stats.inc (rai::stat::type::udp, rai::stat::detail::blocking, rai::stat::dir::in); + stats.inc (nano::stat::type::udp, nano::stat::detail::blocking, nano::stat::dir::in); condition.wait (lock); } - rai::udp_data * result (nullptr); + nano::udp_data * result (nullptr); if (!free.empty ()) { result = free.front (); @@ -3691,11 +3691,11 @@ rai::udp_data * rai::udp_buffer::allocate () { result = full.front (); full.pop_front (); - stats.inc (rai::stat::type::udp, rai::stat::detail::overflow, rai::stat::dir::in); + stats.inc (nano::stat::type::udp, nano::stat::detail::overflow, nano::stat::dir::in); } return result; } -void rai::udp_buffer::enqueue (rai::udp_data * data_a) +void nano::udp_buffer::enqueue (nano::udp_data * data_a) { assert (data_a != nullptr); { @@ -3704,14 +3704,14 @@ void rai::udp_buffer::enqueue (rai::udp_data * data_a) } condition.notify_all (); } -rai::udp_data * rai::udp_buffer::dequeue () +nano::udp_data * nano::udp_buffer::dequeue () { std::unique_lock lock (mutex); while (!stopped && full.empty ()) { condition.wait (lock); } - rai::udp_data * result (nullptr); + nano::udp_data * result (nullptr); if (!full.empty ()) { result = full.front (); @@ -3719,7 +3719,7 @@ rai::udp_data * rai::udp_buffer::dequeue () } return result; } -void rai::udp_buffer::release (rai::udp_data * data_a) +void nano::udp_buffer::release (nano::udp_data * data_a) { assert (data_a != nullptr); { @@ -3728,7 +3728,7 @@ void rai::udp_buffer::release (rai::udp_data * data_a) } condition.notify_all (); } -void rai::udp_buffer::stop () +void nano::udp_buffer::stop () { { std::lock_guard lock (mutex); diff --git a/nano/node/node.hpp b/nano/node/node.hpp new file mode 100644 index 00000000..fcfe59f9 --- /dev/null +++ b/nano/node/node.hpp @@ -0,0 +1,553 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include +#include +#include +#include +#include +#include +#include + +namespace nano +{ +class node; +class election_status +{ +public: + std::shared_ptr winner; + nano::amount tally; + std::chrono::milliseconds election_end; + std::chrono::milliseconds election_duration; +}; +class vote_info +{ +public: + std::chrono::steady_clock::time_point time; + uint64_t sequence; + nano::block_hash hash; +}; +class election_vote_result +{ +public: + election_vote_result (); + election_vote_result (bool, bool); + bool replay; + bool processed; +}; +class election : public std::enable_shared_from_this +{ + std::function)> confirmation_action; + void confirm_once (nano::transaction const &); + void confirm_back (nano::transaction const &); + +public: + election (nano::node &, std::shared_ptr, std::function)> const &); + nano::election_vote_result vote (nano::account, uint64_t, nano::block_hash); + nano::tally_t tally (nano::transaction const &); + // Check if we have vote quorum + bool have_quorum (nano::tally_t const &, nano::uint128_t); + // Change our winner to agree with the network + void compute_rep_votes (nano::transaction const &); + // Confirm this block if quorum is met + void confirm_if_quorum (nano::transaction const &); + void log_votes (nano::tally_t const &); + bool publish (std::shared_ptr block_a); + void stop (); + nano::node & node; + std::unordered_map last_votes; + std::unordered_map> blocks; + nano::block_hash root; + std::chrono::steady_clock::time_point election_start; + nano::election_status status; + std::atomic confirmed; + bool stopped; + std::unordered_map last_tally; + unsigned announcements; +}; +class conflict_info +{ +public: + nano::block_hash root; + uint64_t difficulty; + std::shared_ptr election; +}; +// Core class for determining consensus +// Holds all active blocks i.e. recently added blocks that need confirmation +class active_transactions +{ +public: + active_transactions (nano::node &); + ~active_transactions (); + // Start an election for a block + // Call action with confirmed block, may be different than what we started with + bool start (std::shared_ptr, std::function)> const & = [](std::shared_ptr) {}); + // If this returns true, the vote is a replay + // If this returns false, the vote may or may not be a replay + bool vote (std::shared_ptr, bool = false); + // Is the root of this block in the roots container + bool active (nano::block const &); + void update_difficulty (nano::block const &); + std::deque> list_blocks (bool = false); + void erase (nano::block const &); + void stop (); + bool publish (std::shared_ptr block_a); + boost::multi_index_container< + nano::conflict_info, + boost::multi_index::indexed_by< + boost::multi_index::hashed_unique< + boost::multi_index::member>, + boost::multi_index::ordered_non_unique< + boost::multi_index::member, + std::greater>>> + roots; + std::unordered_map> blocks; + std::deque confirmed; + nano::node & node; + std::mutex mutex; + // Maximum number of conflicts to vote on per interval, lowest root hash first + static unsigned constexpr announcements_per_interval = 32; + // Minimum number of block announcements + static unsigned constexpr announcement_min = 2; + // Threshold to start logging blocks haven't yet been confirmed + static unsigned constexpr announcement_long = 20; + static unsigned constexpr announce_interval_ms = (nano::nano_network == nano::nano_networks::nano_test_network) ? 10 : 16000; + static size_t constexpr election_history_size = 2048; + static size_t constexpr max_broadcast_queue = 1000; + +private: + // Call action with confirmed block, may be different than what we started with + bool add (std::shared_ptr, std::function)> const & = [](std::shared_ptr) {}); + void announce_loop (); + void announce_votes (std::unique_lock &); + std::condition_variable condition; + bool started; + bool stopped; + boost::thread thread; +}; +class operation +{ +public: + bool operator> (nano::operation const &) const; + std::chrono::steady_clock::time_point wakeup; + std::function function; +}; +class alarm +{ +public: + alarm (boost::asio::io_context &); + ~alarm (); + void add (std::chrono::steady_clock::time_point const &, std::function const &); + void run (); + boost::asio::io_context & io_ctx; + std::mutex mutex; + std::condition_variable condition; + std::priority_queue, std::greater> operations; + boost::thread thread; +}; +class gap_information +{ +public: + std::chrono::steady_clock::time_point arrival; + nano::block_hash hash; + std::unordered_set voters; +}; +class gap_cache +{ +public: + gap_cache (nano::node &); + void add (nano::transaction const &, std::shared_ptr); + void vote (std::shared_ptr); + nano::uint128_t bootstrap_threshold (nano::transaction const &); + boost::multi_index_container< + nano::gap_information, + boost::multi_index::indexed_by< + boost::multi_index::ordered_non_unique>, + boost::multi_index::hashed_unique>>> + blocks; + size_t const max = 256; + std::mutex mutex; + nano::node & node; +}; +class work_pool; +class send_info +{ +public: + uint8_t const * data; + size_t size; + nano::endpoint endpoint; + std::function callback; +}; +class block_arrival_info +{ +public: + std::chrono::steady_clock::time_point arrival; + nano::block_hash hash; +}; +// This class tracks blocks that are probably live because they arrived in a UDP packet +// This gives a fairly reliable way to differentiate between blocks being inserted via bootstrap or new, live blocks. +class block_arrival +{ +public: + // Return `true' to indicated an error if the block has already been inserted + bool add (nano::block_hash const &); + bool recent (nano::block_hash const &); + boost::multi_index_container< + nano::block_arrival_info, + boost::multi_index::indexed_by< + boost::multi_index::ordered_non_unique>, + boost::multi_index::hashed_unique>>> + arrival; + std::mutex mutex; + static size_t constexpr arrival_size_min = 8 * 1024; + static std::chrono::seconds constexpr arrival_time_min = std::chrono::seconds (300); +}; +class rep_last_heard_info +{ +public: + std::chrono::steady_clock::time_point last_heard; + nano::account representative; +}; +class online_reps +{ +public: + online_reps (nano::node &); + void vote (std::shared_ptr const &); + void recalculate_stake (); + nano::uint128_t online_stake (); + nano::uint128_t online_stake_total; + std::vector list (); + boost::multi_index_container< + nano::rep_last_heard_info, + boost::multi_index::indexed_by< + boost::multi_index::ordered_non_unique>, + boost::multi_index::hashed_unique>>> + reps; + +private: + std::mutex mutex; + nano::node & node; +}; +class udp_data +{ +public: + uint8_t * buffer; + size_t size; + nano::endpoint endpoint; +}; +/** + * A circular buffer for servicing UDP datagrams. This container follows a producer/consumer model where the operating system is producing data in to buffers which are serviced by internal threads. + * If buffers are not serviced fast enough they're internally dropped. + * This container has a maximum space to hold N buffers of M size and will allocate them in round-robin order. + * All public methods are thread-safe +*/ +class udp_buffer +{ +public: + // Stats - Statistics + // Size - Size of each individual buffer + // Count - Number of buffers to allocate + udp_buffer (nano::stat & stats, size_t, size_t); + // Return a buffer where UDP data can be put + // Method will attempt to return the first free buffer + // If there are no free buffers, an unserviced buffer will be dequeued and returned + // Function will block if there are no free or unserviced buffers + // Return nullptr if the container has stopped + nano::udp_data * allocate (); + // Queue a buffer that has been filled with UDP data and notify servicing threads + void enqueue (nano::udp_data *); + // Return a buffer that has been filled with UDP data + // Function will block until a buffer has been added + // Return nullptr if the container has stopped + nano::udp_data * dequeue (); + // Return a buffer to the freelist after is has been serviced + void release (nano::udp_data *); + // Stop container and notify waiting threads + void stop (); + +private: + nano::stat & stats; + std::mutex mutex; + std::condition_variable condition; + boost::circular_buffer free; + boost::circular_buffer full; + std::vector slab; + std::vector entries; + bool stopped; +}; +class network +{ +public: + network (nano::node &, uint16_t); + ~network (); + void receive (); + void process_packets (); + void start (); + void stop (); + void receive_action (nano::udp_data *); + void rpc_action (boost::system::error_code const &, size_t); + void republish_vote (std::shared_ptr); + void republish_block (std::shared_ptr); + static unsigned const broadcast_interval_ms = 10; + void republish_block_batch (std::deque>, unsigned = broadcast_interval_ms); + void republish (nano::block_hash const &, std::shared_ptr>, nano::endpoint); + void confirm_send (nano::confirm_ack const &, std::shared_ptr>, nano::endpoint const &); + void merge_peers (std::array const &); + void send_keepalive (nano::endpoint const &); + void send_node_id_handshake (nano::endpoint const &, boost::optional const & query, boost::optional const & respond_to); + void broadcast_confirm_req (std::shared_ptr); + void broadcast_confirm_req_base (std::shared_ptr, std::shared_ptr>, unsigned, bool = false); + void broadcast_confirm_req_batch (std::deque, std::shared_ptr>>>, unsigned = broadcast_interval_ms); + void send_confirm_req (nano::endpoint const &, std::shared_ptr); + void send_buffer (uint8_t const *, size_t, nano::endpoint const &, std::function); + nano::endpoint endpoint (); + nano::udp_buffer buffer_container; + boost::asio::ip::udp::socket socket; + std::mutex socket_mutex; + boost::asio::ip::udp::resolver resolver; + std::vector packet_processing_threads; + nano::node & node; + bool on; + static uint16_t const node_port = nano::nano_network == nano::nano_networks::nano_live_network ? 7075 : 54000; + static size_t const buffer_size = 512; +}; + +class node_init +{ +public: + node_init (); + bool error (); + bool block_store_init; + bool wallet_init; +}; +class node_observers +{ +public: + nano::observer_set, nano::account const &, nano::uint128_t const &, bool> blocks; + nano::observer_set wallet; + nano::observer_set, nano::endpoint const &> vote; + nano::observer_set account_balance; + nano::observer_set endpoint; + nano::observer_set<> disconnect; +}; +class vote_processor +{ +public: + vote_processor (nano::node &); + void vote (std::shared_ptr, nano::endpoint); + // node.active.mutex lock required + nano::vote_code vote_blocking (nano::transaction const &, std::shared_ptr, nano::endpoint, bool = false); + void verify_votes (std::deque, nano::endpoint>> &); + void flush (); + void calculate_weights (); + nano::node & node; + void stop (); + +private: + void process_loop (); + std::deque, nano::endpoint>> votes; + // Representatives levels for random early detection + std::unordered_set representatives_1; + std::unordered_set representatives_2; + std::unordered_set representatives_3; + std::condition_variable condition; + std::mutex mutex; + bool started; + bool stopped; + bool active; + boost::thread thread; +}; +// The network is crawled for representatives by occasionally sending a unicast confirm_req for a specific block and watching to see if it's acknowledged with a vote. +class rep_crawler +{ +public: + void add (nano::block_hash const &); + void remove (nano::block_hash const &); + bool exists (nano::block_hash const &); + std::mutex mutex; + std::unordered_set active; +}; +class block_processor; +class signature_check_set +{ +public: + size_t size; + unsigned char const ** messages; + size_t * message_lengths; + unsigned char const ** pub_keys; + unsigned char const ** signatures; + int * verifications; + std::promise * promise; +}; +class signature_checker +{ +public: + signature_checker (); + ~signature_checker (); + void add (signature_check_set &); + void stop (); + void flush (); + +private: + void run (); + void verify (nano::signature_check_set & check_a); + std::deque checks; + bool started; + bool stopped; + std::mutex mutex; + std::condition_variable condition; + std::thread thread; +}; +// Processing blocks is a potentially long IO operation +// This class isolates block insertion from other operations like servicing network operations +class block_processor +{ +public: + block_processor (nano::node &); + ~block_processor (); + void stop (); + void flush (); + bool full (); + void add (std::shared_ptr, std::chrono::steady_clock::time_point); + void force (std::shared_ptr); + bool should_log (bool); + bool have_blocks (); + void process_blocks (); + nano::process_return process_receive_one (nano::transaction const &, std::shared_ptr, std::chrono::steady_clock::time_point = std::chrono::steady_clock::now (), bool = false); + +private: + void queue_unchecked (nano::transaction const &, nano::block_hash const &); + void verify_state_blocks (std::unique_lock &, size_t = std::numeric_limits::max ()); + void process_receive_many (std::unique_lock &); + bool stopped; + bool active; + std::chrono::steady_clock::time_point next_log; + std::deque, std::chrono::steady_clock::time_point>> state_blocks; + std::deque, std::chrono::steady_clock::time_point>> blocks; + std::unordered_set blocks_hashes; + std::deque> forced; + std::condition_variable condition; + nano::node & node; + nano::vote_generator generator; + std::mutex mutex; +}; +class node : public std::enable_shared_from_this +{ +public: + node (nano::node_init &, boost::asio::io_context &, uint16_t, boost::filesystem::path const &, nano::alarm &, nano::logging const &, nano::work_pool &); + node (nano::node_init &, boost::asio::io_context &, boost::filesystem::path const &, nano::alarm &, nano::node_config const &, nano::work_pool &); + ~node (); + template + void background (T action_a) + { + alarm.io_ctx.post (action_a); + } + void send_keepalive (nano::endpoint const &); + bool copy_with_compaction (boost::filesystem::path const &); + void keepalive (std::string const &, uint16_t); + void start (); + void stop (); + std::shared_ptr shared (); + int store_version (); + void process_confirmed (std::shared_ptr); + void process_message (nano::message &, nano::endpoint const &); + void process_active (std::shared_ptr); + nano::process_return process (nano::block const &); + void keepalive_preconfigured (std::vector const &); + nano::block_hash latest (nano::account const &); + nano::uint128_t balance (nano::account const &); + std::shared_ptr block (nano::block_hash const &); + std::pair balance_pending (nano::account const &); + nano::uint128_t weight (nano::account const &); + nano::account representative (nano::account const &); + void ongoing_keepalive (); + void ongoing_syn_cookie_cleanup (); + void ongoing_rep_crawl (); + void ongoing_rep_calculation (); + void ongoing_bootstrap (); + void ongoing_store_flush (); + void backup_wallet (); + void search_pending (); + int price (nano::uint128_t const &, int); + void work_generate_blocking (nano::block &, uint64_t = nano::work_pool::publish_threshold); + uint64_t work_generate_blocking (nano::uint256_union const &, uint64_t = nano::work_pool::publish_threshold); + void work_generate (nano::uint256_union const &, std::function, uint64_t = nano::work_pool::publish_threshold); + void add_initial_peers (); + void block_confirm (std::shared_ptr); + void process_fork (nano::transaction const &, std::shared_ptr); + bool validate_block_by_previous (nano::transaction const &, std::shared_ptr); + nano::uint128_t delta (); + boost::asio::io_context & io_ctx; + nano::node_config config; + nano::node_flags flags; + nano::alarm & alarm; + nano::work_pool & work; + boost::log::sources::logger_mt log; + std::unique_ptr store_impl; + nano::block_store & store; + nano::gap_cache gap_cache; + nano::ledger ledger; + nano::active_transactions active; + nano::network network; + nano::bootstrap_initiator bootstrap_initiator; + nano::bootstrap_listener bootstrap; + nano::peer_container peers; + boost::filesystem::path application_path; + nano::node_observers observers; + nano::wallets wallets; + nano::port_mapping port_mapping; + nano::signature_checker checker; + nano::vote_processor vote_processor; + nano::rep_crawler rep_crawler; + unsigned warmed_up; + nano::block_processor block_processor; + boost::thread block_processor_thread; + nano::block_arrival block_arrival; + nano::online_reps online_reps; + nano::stat stats; + nano::keypair node_id; + nano::block_uniquer block_uniquer; + nano::vote_uniquer vote_uniquer; + static double constexpr price_max = 16.0; + static double constexpr free_cutoff = 1024.0; + static std::chrono::seconds constexpr period = std::chrono::seconds (60); + static std::chrono::seconds constexpr cutoff = period * 5; + static std::chrono::seconds constexpr syn_cookie_cutoff = std::chrono::seconds (5); + static std::chrono::minutes constexpr backup_interval = std::chrono::minutes (5); + static std::chrono::seconds constexpr search_pending_interval = (nano::nano_network == nano::nano_networks::nano_test_network) ? std::chrono::seconds (1) : std::chrono::seconds (5 * 60); +}; +class thread_runner +{ +public: + thread_runner (boost::asio::io_context &, unsigned); + ~thread_runner (); + void join (); + std::vector threads; +}; +class inactive_node +{ +public: + inactive_node (boost::filesystem::path const & path = nano::working_path (), uint16_t = 24000); + ~inactive_node (); + boost::filesystem::path path; + std::shared_ptr io_context; + nano::alarm alarm; + nano::logging logging; + nano::node_init init; + nano::work_pool work; + uint16_t peering_port; + std::shared_ptr node; +}; +} diff --git a/rai/node/nodeconfig.cpp b/nano/node/nodeconfig.cpp similarity index 76% rename from rai/node/nodeconfig.cpp rename to nano/node/nodeconfig.cpp index 49d5ea16..0ac08eb6 100644 --- a/rai/node/nodeconfig.cpp +++ b/nano/node/nodeconfig.cpp @@ -1,19 +1,19 @@ -#include +#include // NOTE: to reduce compile times, this include can be replaced by more narrow includes -// once rai::network is factored out of node.{c|h}pp -#include +// once nano::network is factored out of node.{c|h}pp +#include -rai::node_config::node_config () : -node_config (rai::network::node_port, rai::logging ()) +nano::node_config::node_config () : +node_config (nano::network::node_port, nano::logging ()) { } -rai::node_config::node_config (uint16_t peering_port_a, rai::logging const & logging_a) : +nano::node_config::node_config (uint16_t peering_port_a, nano::logging const & logging_a) : peering_port (peering_port_a), logging (logging_a), bootstrap_fraction_numerator (1), -receive_minimum (rai::xrb_ratio), -online_weight_minimum (60000 * rai::Gxrb_ratio), +receive_minimum (nano::xrb_ratio), +online_weight_minimum (60000 * nano::Gxrb_ratio), online_weight_quorum (50), password_fanout (1024), io_threads (std::max (4, boost::thread::hardware_concurrency ())), @@ -29,30 +29,30 @@ block_processor_batch_max_time (std::chrono::milliseconds (5000)) { const char * epoch_message ("epoch v1 block"); strncpy ((char *)epoch_block_link.bytes.data (), epoch_message, epoch_block_link.bytes.size ()); - epoch_block_signer = rai::genesis_account; - switch (rai::rai_network) + epoch_block_signer = nano::genesis_account; + switch (nano::nano_network) { - case rai::rai_networks::rai_test_network: - preconfigured_representatives.push_back (rai::genesis_account); + case nano::nano_networks::nano_test_network: + preconfigured_representatives.push_back (nano::genesis_account); break; - case rai::rai_networks::rai_beta_network: + case nano::nano_networks::nano_beta_network: preconfigured_peers.push_back ("rai-beta.raiblocks.net"); - preconfigured_representatives.push_back (rai::account ("A59A47CC4F593E75AE9AD653FDA9358E2F7898D9ACC8C60E80D0495CE20FBA9F")); - preconfigured_representatives.push_back (rai::account ("259A4011E6CAD1069A97C02C3C1F2AAA32BC093C8D82EE1334F937A4BE803071")); - preconfigured_representatives.push_back (rai::account ("259A40656144FAA16D2A8516F7BE9C74A63C6CA399960EDB747D144ABB0F7ABD")); - preconfigured_representatives.push_back (rai::account ("259A40A92FA42E2240805DE8618EC4627F0BA41937160B4CFF7F5335FD1933DF")); - preconfigured_representatives.push_back (rai::account ("259A40FF3262E273EC451E873C4CDF8513330425B38860D882A16BCC74DA9B73")); + preconfigured_representatives.push_back (nano::account ("A59A47CC4F593E75AE9AD653FDA9358E2F7898D9ACC8C60E80D0495CE20FBA9F")); + preconfigured_representatives.push_back (nano::account ("259A4011E6CAD1069A97C02C3C1F2AAA32BC093C8D82EE1334F937A4BE803071")); + preconfigured_representatives.push_back (nano::account ("259A40656144FAA16D2A8516F7BE9C74A63C6CA399960EDB747D144ABB0F7ABD")); + preconfigured_representatives.push_back (nano::account ("259A40A92FA42E2240805DE8618EC4627F0BA41937160B4CFF7F5335FD1933DF")); + preconfigured_representatives.push_back (nano::account ("259A40FF3262E273EC451E873C4CDF8513330425B38860D882A16BCC74DA9B73")); break; - case rai::rai_networks::rai_live_network: + case nano::nano_networks::nano_live_network: preconfigured_peers.push_back ("rai.raiblocks.net"); - preconfigured_representatives.push_back (rai::account ("A30E0A32ED41C8607AA9212843392E853FCBCB4E7CB194E35C94F07F91DE59EF")); - preconfigured_representatives.push_back (rai::account ("67556D31DDFC2A440BF6147501449B4CB9572278D034EE686A6BEE29851681DF")); - preconfigured_representatives.push_back (rai::account ("5C2FBB148E006A8E8BA7A75DD86C9FE00C83F5FFDBFD76EAA09531071436B6AF")); - preconfigured_representatives.push_back (rai::account ("AE7AC63990DAAAF2A69BF11C913B928844BF5012355456F2F164166464024B29")); - preconfigured_representatives.push_back (rai::account ("BD6267D6ECD8038327D2BCC0850BDF8F56EC0414912207E81BCF90DFAC8A4AAA")); - preconfigured_representatives.push_back (rai::account ("2399A083C600AA0572F5E36247D978FCFC840405F8D4B6D33161C0066A55F431")); - preconfigured_representatives.push_back (rai::account ("2298FAB7C61058E77EA554CB93EDEEDA0692CBFCC540AB213B2836B29029E23A")); - preconfigured_representatives.push_back (rai::account ("3FE80B4BC842E82C1C18ABFEEC47EA989E63953BC82AC411F304D13833D52A56")); + preconfigured_representatives.push_back (nano::account ("A30E0A32ED41C8607AA9212843392E853FCBCB4E7CB194E35C94F07F91DE59EF")); + preconfigured_representatives.push_back (nano::account ("67556D31DDFC2A440BF6147501449B4CB9572278D034EE686A6BEE29851681DF")); + preconfigured_representatives.push_back (nano::account ("5C2FBB148E006A8E8BA7A75DD86C9FE00C83F5FFDBFD76EAA09531071436B6AF")); + preconfigured_representatives.push_back (nano::account ("AE7AC63990DAAAF2A69BF11C913B928844BF5012355456F2F164166464024B29")); + preconfigured_representatives.push_back (nano::account ("BD6267D6ECD8038327D2BCC0850BDF8F56EC0414912207E81BCF90DFAC8A4AAA")); + preconfigured_representatives.push_back (nano::account ("2399A083C600AA0572F5E36247D978FCFC840405F8D4B6D33161C0066A55F431")); + preconfigured_representatives.push_back (nano::account ("2298FAB7C61058E77EA554CB93EDEEDA0692CBFCC540AB213B2836B29029E23A")); + preconfigured_representatives.push_back (nano::account ("3FE80B4BC842E82C1C18ABFEEC47EA989E63953BC82AC411F304D13833D52A56")); break; default: assert (false); @@ -60,7 +60,7 @@ block_processor_batch_max_time (std::chrono::milliseconds (5000)) } } -void rai::node_config::serialize_json (boost::property_tree::ptree & tree_a) const +void nano::node_config::serialize_json (boost::property_tree::ptree & tree_a) const { tree_a.put ("version", std::to_string (json_version)); tree_a.put ("peering_port", std::to_string (peering_port)); @@ -110,7 +110,7 @@ void rai::node_config::serialize_json (boost::property_tree::ptree & tree_a) con tree_a.put ("allow_local_peers", allow_local_peers); } -bool rai::node_config::upgrade_json (unsigned version_a, boost::property_tree::ptree & tree_a) +bool nano::node_config::upgrade_json (unsigned version_a, boost::property_tree::ptree & tree_a) { tree_a.put ("version", std::to_string (json_version)); auto result (false); @@ -122,7 +122,7 @@ bool rai::node_config::upgrade_json (unsigned version_a, boost::property_tree::p boost::property_tree::ptree reps; for (auto i (reps_l.begin ()), n (reps_l.end ()); i != n; ++i) { - rai::uint256_union account; + nano::uint256_union account; account.decode_account (i->second.get ("")); boost::property_tree::ptree entry; entry.put ("", account.to_account ()); @@ -134,7 +134,7 @@ bool rai::node_config::upgrade_json (unsigned version_a, boost::property_tree::p } case 2: { - tree_a.put ("inactive_supply", rai::uint128_union (0).to_string_dec ()); + tree_a.put ("inactive_supply", nano::uint128_union (0).to_string_dec ()); tree_a.put ("password_fanout", std::to_string (1024)); tree_a.put ("io_threads", std::to_string (io_threads)); tree_a.put ("work_threads", std::to_string (work_threads)); @@ -142,11 +142,11 @@ bool rai::node_config::upgrade_json (unsigned version_a, boost::property_tree::p } case 3: tree_a.erase ("receive_minimum"); - tree_a.put ("receive_minimum", rai::xrb_ratio.convert_to ()); + tree_a.put ("receive_minimum", nano::xrb_ratio.convert_to ()); result = true; case 4: tree_a.erase ("receive_minimum"); - tree_a.put ("receive_minimum", rai::xrb_ratio.convert_to ()); + tree_a.put ("receive_minimum", nano::xrb_ratio.convert_to ()); result = true; case 5: tree_a.put ("enable_voting", enable_voting); @@ -167,8 +167,8 @@ bool rai::node_config::upgrade_json (unsigned version_a, boost::property_tree::p tree_a.put ("bootstrap_connections_max", "64"); result = true; case 9: - tree_a.put ("state_block_parse_canary", rai::block_hash (0).to_string ()); - tree_a.put ("state_block_generate_canary", rai::block_hash (0).to_string ()); + tree_a.put ("state_block_parse_canary", nano::block_hash (0).to_string ()); + tree_a.put ("state_block_generate_canary", nano::block_hash (0).to_string ()); result = true; case 10: tree_a.put ("online_weight_minimum", online_weight_minimum.to_string_dec ()); @@ -205,7 +205,7 @@ bool rai::node_config::upgrade_json (unsigned version_a, boost::property_tree::p return result; } -bool rai::node_config::deserialize_json (bool & upgraded_a, boost::property_tree::ptree & tree_a) +bool nano::node_config::deserialize_json (bool & upgraded_a, boost::property_tree::ptree & tree_a) { auto result (false); try @@ -257,7 +257,7 @@ bool rai::node_config::deserialize_json (bool & upgraded_a, boost::property_tree preconfigured_representatives.clear (); for (auto i (preconfigured_representatives_l.begin ()), n (preconfigured_representatives_l.end ()); i != n; ++i) { - rai::account representative (0); + nano::account representative (0); result = result || representative.decode_account (i->second.get ("")); preconfigured_representatives.push_back (representative); } @@ -318,15 +318,15 @@ bool rai::node_config::deserialize_json (bool & upgraded_a, boost::property_tree return result; } -rai::account rai::node_config::random_representative () +nano::account nano::node_config::random_representative () { assert (preconfigured_representatives.size () > 0); - size_t index (rai::random_pool.GenerateWord32 (0, preconfigured_representatives.size () - 1)); + size_t index (nano::random_pool.GenerateWord32 (0, preconfigured_representatives.size () - 1)); auto result (preconfigured_representatives[index]); return result; } -rai::node_flags::node_flags () : +nano::node_flags::node_flags () : disable_backup (false), disable_lazy_bootstrap (false), disable_legacy_bootstrap (false), diff --git a/rai/node/nodeconfig.hpp b/nano/node/nodeconfig.hpp similarity index 75% rename from rai/node/nodeconfig.hpp rename to nano/node/nodeconfig.hpp index 3110ad8e..ecb90d0d 100644 --- a/rai/node/nodeconfig.hpp +++ b/nano/node/nodeconfig.hpp @@ -2,12 +2,12 @@ #include #include -#include -#include -#include +#include +#include +#include #include -namespace rai +namespace nano { /** * Node configuration @@ -16,19 +16,19 @@ class node_config { public: node_config (); - node_config (uint16_t, rai::logging const &); + node_config (uint16_t, nano::logging const &); void serialize_json (boost::property_tree::ptree &) const; bool deserialize_json (bool &, boost::property_tree::ptree &); bool upgrade_json (unsigned, boost::property_tree::ptree &); - rai::account random_representative (); + nano::account random_representative (); uint16_t peering_port; - rai::logging logging; + nano::logging logging; std::vector> work_peers; std::vector preconfigured_peers; - std::vector preconfigured_representatives; + std::vector preconfigured_representatives; unsigned bootstrap_fraction_numerator; - rai::amount receive_minimum; - rai::amount online_weight_minimum; + nano::amount receive_minimum; + nano::amount online_weight_minimum; unsigned online_weight_quorum; unsigned password_fanout; unsigned io_threads; @@ -42,9 +42,9 @@ public: std::string callback_target; int lmdb_max_dbs; bool allow_local_peers; - rai::stat_config stat_config; - rai::uint256_union epoch_block_link; - rai::account epoch_block_signer; + nano::stat_config stat_config; + nano::uint256_union epoch_block_link; + nano::account epoch_block_signer; std::chrono::milliseconds block_processor_batch_max_time; static std::chrono::seconds constexpr keepalive_period = std::chrono::seconds (60); static std::chrono::seconds constexpr keepalive_cutoff = keepalive_period * 5; diff --git a/rai/node/openclwork.cpp b/nano/node/openclwork.cpp similarity index 92% rename from rai/node/openclwork.cpp rename to nano/node/openclwork.cpp index d92a7afc..f617203b 100644 --- a/rai/node/openclwork.cpp +++ b/nano/node/openclwork.cpp @@ -1,8 +1,8 @@ -#include +#include -#include -#include -#include +#include +#include +#include #include #include @@ -359,7 +359,7 @@ static void ucharcpyglb (uchar * dst, __global uchar const * src, size_t count) } } -__kernel void raiblocks_work (__global ulong * attempt, __global ulong * result_a, __global uchar * item_a) +__kernel void nano_work (__global ulong * attempt, __global ulong * result_a, __global uchar * item_a) { int const thread = get_global_id (0); uchar item_l [32]; @@ -401,7 +401,7 @@ void printstate (blake2b_state * S) << std::dec << std::endl; } -rai::opencl_environment::opencl_environment (bool & error_a) +nano::opencl_environment::opencl_environment (bool & error_a) { cl_uint platformIdCount = 0; clGetPlatformIDs (0, nullptr, &platformIdCount); @@ -409,7 +409,7 @@ rai::opencl_environment::opencl_environment (bool & error_a) clGetPlatformIDs (platformIdCount, platformIds.data (), nullptr); for (auto i (platformIds.begin ()), n (platformIds.end ()); i != n; ++i) { - rai::opencl_platform platform; + nano::opencl_platform platform; platform.platform = *i; cl_uint deviceIdCount = 0; clGetDeviceIDs (*i, CL_DEVICE_TYPE_ALL, 0, nullptr, &deviceIdCount); @@ -423,7 +423,7 @@ rai::opencl_environment::opencl_environment (bool & error_a) } } -void rai::opencl_environment::dump (std::ostream & stream) +void nano::opencl_environment::dump (std::ostream & stream) { auto index (0); auto device_count (0); @@ -498,28 +498,28 @@ void rai::opencl_environment::dump (std::ostream & stream) } } -rai::opencl_config::opencl_config () : +nano::opencl_config::opencl_config () : platform (0), device (0), threads (1024 * 1024) { } -rai::opencl_config::opencl_config (unsigned platform_a, unsigned device_a, unsigned threads_a) : +nano::opencl_config::opencl_config (unsigned platform_a, unsigned device_a, unsigned threads_a) : platform (platform_a), device (device_a), threads (threads_a) { } -void rai::opencl_config::serialize_json (boost::property_tree::ptree & tree_a) const +void nano::opencl_config::serialize_json (boost::property_tree::ptree & tree_a) const { tree_a.put ("platform", std::to_string (platform)); tree_a.put ("device", std::to_string (device)); tree_a.put ("threads", std::to_string (threads)); } -bool rai::opencl_config::deserialize_json (boost::property_tree::ptree const & tree_a) +bool nano::opencl_config::deserialize_json (boost::property_tree::ptree const & tree_a) { auto result (false); try @@ -545,7 +545,7 @@ bool rai::opencl_config::deserialize_json (boost::property_tree::ptree const & t return result; } -rai::opencl_work::opencl_work (bool & error_a, rai::opencl_config const & config_a, rai::opencl_environment & environment_a, rai::logging & logging_a) : +nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & config_a, nano::opencl_environment & environment_a, nano::logging & logging_a) : config (config_a), context (0), attempt_buffer (0), @@ -563,7 +563,7 @@ logging (logging_a) error_a |= config.device >= platform.devices.size (); if (!error_a) { - rai::random_pool.GenerateBlock (reinterpret_cast (rand.s.data ()), rand.s.size () * sizeof (decltype (rand.s)::value_type)); + nano::random_pool.GenerateBlock (reinterpret_cast (rand.s.data ()), rand.s.size () * sizeof (decltype (rand.s)::value_type)); std::array selected_devices; selected_devices[0] = platform.devices[config.device]; cl_context_properties contextProperties[] = { @@ -592,7 +592,7 @@ logging (logging_a) if (!error_a) { cl_int item_error (0); - size_t item_size (sizeof (rai::uint256_union)); + size_t item_size (sizeof (nano::uint256_union)); item_buffer = clCreateBuffer (context, 0, item_size, nullptr, &item_error); error_a |= item_error != CL_SUCCESS; if (!error_a) @@ -609,7 +609,7 @@ logging (logging_a) if (!error_a) { cl_int kernel_error (0); - kernel = clCreateKernel (program, "raiblocks_work", &kernel_error); + kernel = clCreateKernel (program, "nano_work", &kernel_error); error_a |= kernel_error != CL_SUCCESS; if (!error_a) { @@ -700,7 +700,7 @@ logging (logging_a) } } -rai::opencl_work::~opencl_work () +nano::opencl_work::~opencl_work () { if (kernel != 0) { @@ -716,20 +716,20 @@ rai::opencl_work::~opencl_work () } } -boost::optional rai::opencl_work::generate_work (rai::uint256_union const & root_a) +boost::optional nano::opencl_work::generate_work (nano::uint256_union const & root_a) { std::lock_guard lock (mutex); bool error (false); uint64_t result (0); unsigned thread_count (config.threads); size_t work_size[] = { thread_count, 0, 0 }; - while (rai::work_validate (root_a, result) && !error) + while (nano::work_validate (root_a, result) && !error) { result = rand.next (); cl_int write_error1 = clEnqueueWriteBuffer (queue, attempt_buffer, false, 0, sizeof (uint64_t), &result, 0, nullptr, nullptr); if (write_error1 == CL_SUCCESS) { - cl_int write_error2 = clEnqueueWriteBuffer (queue, item_buffer, false, 0, sizeof (rai::uint256_union), root_a.bytes.data (), 0, nullptr, nullptr); + cl_int write_error2 = clEnqueueWriteBuffer (queue, item_buffer, false, 0, sizeof (nano::uint256_union), root_a.bytes.data (), 0, nullptr, nullptr); if (write_error2 == CL_SUCCESS) { cl_int enqueue_error = clEnqueueNDRangeKernel (queue, kernel, 1, nullptr, work_size, nullptr, 0, nullptr, nullptr); @@ -780,19 +780,19 @@ boost::optional rai::opencl_work::generate_work (rai::uint256_union co return value; } -std::unique_ptr rai::opencl_work::create (bool create_a, rai::opencl_config const & config_a, rai::logging & logging_a) +std::unique_ptr nano::opencl_work::create (bool create_a, nano::opencl_config const & config_a, nano::logging & logging_a) { - std::unique_ptr result; + std::unique_ptr result; if (create_a) { auto error (false); - rai::opencl_environment environment (error); + nano::opencl_environment environment (error); std::stringstream stream; environment.dump (stream); BOOST_LOG (logging_a.log) << stream.str (); if (!error) { - result.reset (new rai::opencl_work (error, config_a, environment, logging_a)); + result.reset (new nano::opencl_work (error, config_a, environment, logging_a)); if (error) { result.reset (); diff --git a/rai/node/openclwork.hpp b/nano/node/openclwork.hpp similarity index 69% rename from rai/node/openclwork.hpp rename to nano/node/openclwork.hpp index 0e766397..e6c37b94 100644 --- a/rai/node/openclwork.hpp +++ b/nano/node/openclwork.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include #include #include @@ -16,7 +16,7 @@ #include #endif -namespace rai +namespace nano { class logging; class opencl_platform @@ -30,7 +30,7 @@ class opencl_environment public: opencl_environment (bool &); void dump (std::ostream & stream); - std::vector platforms; + std::vector platforms; }; union uint256_union; class work_pool; @@ -48,11 +48,11 @@ public: class opencl_work { public: - opencl_work (bool &, rai::opencl_config const &, rai::opencl_environment &, rai::logging &); + opencl_work (bool &, nano::opencl_config const &, nano::opencl_environment &, nano::logging &); ~opencl_work (); - boost::optional generate_work (rai::uint256_union const &); - static std::unique_ptr create (bool, rai::opencl_config const &, rai::logging &); - rai::opencl_config const & config; + boost::optional generate_work (nano::uint256_union const &); + static std::unique_ptr create (bool, nano::opencl_config const &, nano::logging &); + nano::opencl_config const & config; std::mutex mutex; cl_context context; cl_mem attempt_buffer; @@ -61,7 +61,7 @@ public: cl_program program; cl_kernel kernel; cl_command_queue queue; - rai::xorshift1024star rand; - rai::logging & logging; + nano::xorshift1024star rand; + nano::logging & logging; }; } diff --git a/rai/node/peers.cpp b/nano/node/peers.cpp similarity index 66% rename from rai/node/peers.cpp rename to nano/node/peers.cpp index 6d1f05bf..4af128e1 100644 --- a/rai/node/peers.cpp +++ b/nano/node/peers.cpp @@ -1,16 +1,16 @@ -#include +#include -rai::endpoint rai::map_endpoint_to_v6 (rai::endpoint const & endpoint_a) +nano::endpoint nano::map_endpoint_to_v6 (nano::endpoint const & endpoint_a) { auto endpoint_l (endpoint_a); if (endpoint_l.address ().is_v4 ()) { - endpoint_l = rai::endpoint (boost::asio::ip::address_v6::v4_mapped (endpoint_l.address ().to_v4 ()), endpoint_l.port ()); + endpoint_l = nano::endpoint (boost::asio::ip::address_v6::v4_mapped (endpoint_l.address ().to_v4 ()), endpoint_l.port ()); } return endpoint_l; } -rai::peer_information::peer_information (rai::endpoint const & endpoint_a, unsigned network_version_a) : +nano::peer_information::peer_information (nano::endpoint const & endpoint_a, unsigned network_version_a) : endpoint (endpoint_a), ip_address (endpoint_a.address ()), last_contact (std::chrono::steady_clock::now ()), @@ -24,7 +24,7 @@ node_id () { } -rai::peer_information::peer_information (rai::endpoint const & endpoint_a, std::chrono::steady_clock::time_point const & last_contact_a, std::chrono::steady_clock::time_point const & last_attempt_a) : +nano::peer_information::peer_information (nano::endpoint const & endpoint_a, std::chrono::steady_clock::time_point const & last_contact_a, std::chrono::steady_clock::time_point const & last_attempt_a) : endpoint (endpoint_a), ip_address (endpoint_a.address ()), last_contact (last_contact_a), @@ -33,23 +33,23 @@ last_bootstrap_attempt (std::chrono::steady_clock::time_point ()), last_rep_request (std::chrono::steady_clock::time_point ()), last_rep_response (std::chrono::steady_clock::time_point ()), rep_weight (0), -network_version (rai::protocol_version), +network_version (nano::protocol_version), node_id () { } -rai::peer_container::peer_container (rai::endpoint const & self_a) : +nano::peer_container::peer_container (nano::endpoint const & self_a) : self (self_a), -peer_observer ([](rai::endpoint const &) {}), +peer_observer ([](nano::endpoint const &) {}), disconnect_observer ([]() {}) { } -bool rai::peer_container::contacted (rai::endpoint const & endpoint_a, unsigned version_a) +bool nano::peer_container::contacted (nano::endpoint const & endpoint_a, unsigned version_a) { - auto endpoint_l (rai::map_endpoint_to_v6 (endpoint_a)); + auto endpoint_l (nano::map_endpoint_to_v6 (endpoint_a)); auto should_handshake (false); - if (version_a < rai::node_id_version) + if (version_a < nano::node_id_version) { insert (endpoint_l, version_a); } @@ -57,7 +57,7 @@ bool rai::peer_container::contacted (rai::endpoint const & endpoint_a, unsigned { std::lock_guard lock (mutex); - if (peers.get ().count (endpoint_l.address ()) < max_peers_per_ip) + if (peers.get ().count (endpoint_l.address ()) < max_peers_per_ip) { should_handshake = true; } @@ -65,7 +65,7 @@ bool rai::peer_container::contacted (rai::endpoint const & endpoint_a, unsigned return should_handshake; } -bool rai::peer_container::known_peer (rai::endpoint const & endpoint_a) +bool nano::peer_container::known_peer (nano::endpoint const & endpoint_a) { std::lock_guard lock (mutex); auto existing (peers.find (endpoint_a)); @@ -73,10 +73,10 @@ bool rai::peer_container::known_peer (rai::endpoint const & endpoint_a) } // Simulating with sqrt_broadcast_simulate shows we only need to broadcast to sqrt(total_peers) random peers in order to successfully publish to everyone with high probability -std::deque rai::peer_container::list_fanout () +std::deque nano::peer_container::list_fanout () { auto peers (random_set (size_sqrt ())); - std::deque result; + std::deque result; for (auto i (peers.begin ()), n (peers.end ()); i != n; ++i) { result.push_back (*i); @@ -84,9 +84,9 @@ std::deque rai::peer_container::list_fanout () return result; } -std::deque rai::peer_container::list () +std::deque nano::peer_container::list () { - std::deque result; + std::deque result; std::lock_guard lock (mutex); for (auto i (peers.begin ()), j (peers.end ()); i != j; ++i) { @@ -96,18 +96,18 @@ std::deque rai::peer_container::list () return result; } -std::map rai::peer_container::list_version () +std::map nano::peer_container::list_version () { - std::map result; + std::map result; std::lock_guard lock (mutex); for (auto i (peers.begin ()), j (peers.end ()); i != j; ++i) { - result.insert (std::pair (i->endpoint, i->network_version)); + result.insert (std::pair (i->endpoint, i->network_version)); } return result; } -std::vector rai::peer_container::list_vector (size_t count_a) +std::vector nano::peer_container::list_vector (size_t count_a) { std::vector result; std::lock_guard lock (mutex); @@ -118,14 +118,14 @@ std::vector rai::peer_container::list_vector (size_t coun std::random_shuffle (result.begin (), result.end ()); if (result.size () > count_a) { - result.resize (count_a, rai::peer_information (rai::endpoint{}, 0)); + result.resize (count_a, nano::peer_information (nano::endpoint{}, 0)); } return result; } -rai::endpoint rai::peer_container::bootstrap_peer () +nano::endpoint nano::peer_container::bootstrap_peer () { - rai::endpoint result (boost::asio::ip::address_v6::any (), 0); + nano::endpoint result (boost::asio::ip::address_v6::any (), 0); std::lock_guard lock (mutex); ; for (auto i (peers.get<4> ().begin ()), n (peers.get<4> ().end ()); i != n;) @@ -133,7 +133,7 @@ rai::endpoint rai::peer_container::bootstrap_peer () if (i->network_version >= protocol_version_reasonable_min) { result = i->endpoint; - peers.get<4> ().modify (i, [](rai::peer_information & peer_a) { + peers.get<4> ().modify (i, [](nano::peer_information & peer_a) { peer_a.last_bootstrap_attempt = std::chrono::steady_clock::now (); }); i = n; @@ -146,18 +146,18 @@ rai::endpoint rai::peer_container::bootstrap_peer () return result; } -boost::optional rai::peer_container::assign_syn_cookie (rai::endpoint const & endpoint) +boost::optional nano::peer_container::assign_syn_cookie (nano::endpoint const & endpoint) { auto ip_addr (endpoint.address ()); assert (ip_addr.is_v6 ()); std::unique_lock lock (syn_cookie_mutex); unsigned & ip_cookies = syn_cookies_per_ip[ip_addr]; - boost::optional result; + boost::optional result; if (ip_cookies < max_peers_per_ip) { if (syn_cookies.find (endpoint) == syn_cookies.end ()) { - rai::uint256_union query; + nano::uint256_union query; random_pool.GenerateBlock (query.bytes.data (), query.bytes.size ()); syn_cookie_info info{ query, std::chrono::steady_clock::now () }; syn_cookies[endpoint] = info; @@ -168,14 +168,14 @@ boost::optional rai::peer_container::assign_syn_cookie (rai: return result; } -bool rai::peer_container::validate_syn_cookie (rai::endpoint const & endpoint, rai::account node_id, rai::signature sig) +bool nano::peer_container::validate_syn_cookie (nano::endpoint const & endpoint, nano::account node_id, nano::signature sig) { auto ip_addr (endpoint.address ()); assert (ip_addr.is_v6 ()); std::unique_lock lock (syn_cookie_mutex); auto result (true); auto cookie_it (syn_cookies.find (endpoint)); - if (cookie_it != syn_cookies.end () && !rai::validate_message (node_id, cookie_it->second.cookie, sig)) + if (cookie_it != syn_cookies.end () && !nano::validate_message (node_id, cookie_it->second.cookie, sig)) { result = false; syn_cookies.erase (cookie_it); @@ -192,9 +192,9 @@ bool rai::peer_container::validate_syn_cookie (rai::endpoint const & endpoint, r return result; } -std::unordered_set rai::peer_container::random_set (size_t count_a) +std::unordered_set nano::peer_container::random_set (size_t count_a) { - std::unordered_set result; + std::unordered_set result; result.reserve (count_a); std::lock_guard lock (mutex); // Stop trying to fill result with random samples after this many attempts @@ -218,11 +218,11 @@ std::unordered_set rai::peer_container::random_set (size_t count_ return result; } -void rai::peer_container::random_fill (std::array & target_a) +void nano::peer_container::random_fill (std::array & target_a) { auto peers (random_set (target_a.size ())); assert (peers.size () <= target_a.size ()); - auto endpoint (rai::endpoint (boost::asio::ip::address_v6{}, 0)); + auto endpoint (nano::endpoint (boost::asio::ip::address_v6{}, 0)); assert (endpoint.address ().is_v6 ()); std::fill (target_a.begin (), target_a.end (), endpoint); auto j (target_a.begin ()); @@ -235,7 +235,7 @@ void rai::peer_container::random_fill (std::array & target_a) } // Request a list of the top known representatives -std::vector rai::peer_container::representatives (size_t count_a) +std::vector nano::peer_container::representatives (size_t count_a) { std::vector result; result.reserve (std::min (count_a, size_t (16))); @@ -250,7 +250,7 @@ std::vector rai::peer_container::representatives (size_t return result; } -void rai::peer_container::purge_syn_cookies (std::chrono::steady_clock::time_point const & cutoff) +void nano::peer_container::purge_syn_cookies (std::chrono::steady_clock::time_point const & cutoff) { std::lock_guard lock (syn_cookie_mutex); auto it (syn_cookies.begin ()); @@ -277,9 +277,9 @@ void rai::peer_container::purge_syn_cookies (std::chrono::steady_clock::time_poi } } -std::vector rai::peer_container::purge_list (std::chrono::steady_clock::time_point const & cutoff) +std::vector nano::peer_container::purge_list (std::chrono::steady_clock::time_point const & cutoff) { - std::vector result; + std::vector result; { std::lock_guard lock (mutex); auto pivot (peers.get<1> ().lower_bound (cutoff)); @@ -288,7 +288,7 @@ std::vector rai::peer_container::purge_list (std::chrono: peers.get<1> ().erase (peers.get<1> ().begin (), pivot); for (auto i (peers.begin ()), n (peers.end ()); i != n; ++i) { - peers.modify (i, [](rai::peer_information & info) { info.last_attempt = std::chrono::steady_clock::now (); }); + peers.modify (i, [](nano::peer_information & info) { info.last_attempt = std::chrono::steady_clock::now (); }); } // Remove keepalive attempt tracking for attempts older than cutoff @@ -302,9 +302,9 @@ std::vector rai::peer_container::purge_list (std::chrono: return result; } -std::vector rai::peer_container::rep_crawl () +std::vector nano::peer_container::rep_crawl () { - std::vector result; + std::vector result; // If there is enough observed peers weight, crawl 10 peers. Otherwise - 40 uint16_t max_count = (total_weight () > online_weight_minimum) ? 10 : 40; result.reserve (max_count); @@ -317,22 +317,22 @@ std::vector rai::peer_container::rep_crawl () return result; } -size_t rai::peer_container::size () +size_t nano::peer_container::size () { std::lock_guard lock (mutex); return peers.size (); } -size_t rai::peer_container::size_sqrt () +size_t nano::peer_container::size_sqrt () { auto result (std::ceil (std::sqrt (size ()))); return result; } -std::vector rai::peer_container::list_probable_rep_weights () +std::vector nano::peer_container::list_probable_rep_weights () { - std::vector result; - std::unordered_set probable_reps; + std::vector result; + std::unordered_set probable_reps; std::lock_guard lock (mutex); for (auto i (peers.get<6> ().begin ()), n (peers.get<6> ().end ()); i != n; ++i) { @@ -349,9 +349,9 @@ std::vector rai::peer_container::list_probable_rep_weight return result; } -rai::uint128_t rai::peer_container::total_weight () +nano::uint128_t nano::peer_container::total_weight () { - rai::uint128_t result (0); + nano::uint128_t result (0); for (auto & entry : list_probable_rep_weights ()) { result = result + entry.rep_weight.number (); @@ -359,19 +359,19 @@ rai::uint128_t rai::peer_container::total_weight () return result; } -bool rai::peer_container::empty () +bool nano::peer_container::empty () { return size () == 0; } -bool rai::peer_container::not_a_peer (rai::endpoint const & endpoint_a, bool blacklist_loopback) +bool nano::peer_container::not_a_peer (nano::endpoint const & endpoint_a, bool blacklist_loopback) { bool result (false); if (endpoint_a.address ().to_v6 ().is_unspecified ()) { result = true; } - else if (rai::reserved_address (endpoint_a, blacklist_loopback)) + else if (nano::reserved_address (endpoint_a, blacklist_loopback)) { result = true; } @@ -382,7 +382,7 @@ bool rai::peer_container::not_a_peer (rai::endpoint const & endpoint_a, bool bla return result; } -bool rai::peer_container::rep_response (rai::endpoint const & endpoint_a, rai::account const & rep_account_a, rai::amount const & weight_a) +bool nano::peer_container::rep_response (nano::endpoint const & endpoint_a, nano::account const & rep_account_a, nano::amount const & weight_a) { assert (endpoint_a.address ().is_v6 ()); auto updated (false); @@ -390,7 +390,7 @@ bool rai::peer_container::rep_response (rai::endpoint const & endpoint_a, rai::a auto existing (peers.find (endpoint_a)); if (existing != peers.end ()) { - peers.modify (existing, [weight_a, &updated, rep_account_a](rai::peer_information & info) { + peers.modify (existing, [weight_a, &updated, rep_account_a](nano::peer_information & info) { info.last_rep_response = std::chrono::steady_clock::now (); if (info.rep_weight < weight_a) { @@ -403,25 +403,25 @@ bool rai::peer_container::rep_response (rai::endpoint const & endpoint_a, rai::a return updated; } -void rai::peer_container::rep_request (rai::endpoint const & endpoint_a) +void nano::peer_container::rep_request (nano::endpoint const & endpoint_a) { std::lock_guard lock (mutex); auto existing (peers.find (endpoint_a)); if (existing != peers.end ()) { - peers.modify (existing, [](rai::peer_information & info) { + peers.modify (existing, [](nano::peer_information & info) { info.last_rep_request = std::chrono::steady_clock::now (); }); } } -bool rai::peer_container::reachout (rai::endpoint const & endpoint_a) +bool nano::peer_container::reachout (nano::endpoint const & endpoint_a) { // Don't contact invalid IPs bool error = not_a_peer (endpoint_a, false); if (!error) { - auto endpoint_l (rai::map_endpoint_to_v6 (endpoint_a)); + auto endpoint_l (nano::map_endpoint_to_v6 (endpoint_a)); // Don't keepalive to nodes that already sent us something error |= known_peer (endpoint_l); std::lock_guard lock (mutex); @@ -432,20 +432,20 @@ bool rai::peer_container::reachout (rai::endpoint const & endpoint_a) return error; } -bool rai::peer_container::insert (rai::endpoint const & endpoint_a, unsigned version_a) +bool nano::peer_container::insert (nano::endpoint const & endpoint_a, unsigned version_a) { assert (endpoint_a.address ().is_v6 ()); auto unknown (false); auto result (not_a_peer (endpoint_a, false)); if (!result) { - if (version_a >= rai::protocol_version_min) + if (version_a >= nano::protocol_version_min) { std::lock_guard lock (mutex); auto existing (peers.find (endpoint_a)); if (existing != peers.end ()) { - peers.modify (existing, [](rai::peer_information & info) { + peers.modify (existing, [](nano::peer_information & info) { info.last_contact = std::chrono::steady_clock::now (); }); result = true; @@ -453,9 +453,9 @@ bool rai::peer_container::insert (rai::endpoint const & endpoint_a, unsigned ver else { unknown = true; - if (!result && rai_network != rai_networks::rai_test_network) + if (!result && nano_network != nano_networks::nano_test_network) { - auto ip_peers (peers.get ().count (endpoint_a.address ())); + auto ip_peers (peers.get ().count (endpoint_a.address ())); if (ip_peers >= max_peers_per_ip) { result = true; @@ -463,7 +463,7 @@ bool rai::peer_container::insert (rai::endpoint const & endpoint_a, unsigned ver } if (!result) { - peers.insert (rai::peer_information (endpoint_a, version_a)); + peers.insert (nano::peer_information (endpoint_a, version_a)); } } } diff --git a/rai/node/peers.hpp b/nano/node/peers.hpp similarity index 68% rename from rai/node/peers.hpp rename to nano/node/peers.hpp index c4f1bf6e..472fff19 100644 --- a/rai/node/peers.hpp +++ b/nano/node/peers.hpp @@ -10,14 +10,14 @@ #include #include #include -#include -#include +#include +#include #include #include -namespace rai +namespace nano { -rai::endpoint map_endpoint_to_v6 (rai::endpoint const &); +nano::endpoint map_endpoint_to_v6 (nano::endpoint const &); /** Multi-index helper */ class peer_by_ip_addr @@ -28,7 +28,7 @@ class peer_by_ip_addr class peer_attempt { public: - rai::endpoint endpoint; + nano::endpoint endpoint; std::chrono::steady_clock::time_point last_attempt; }; @@ -36,7 +36,7 @@ public: class syn_cookie_info { public: - rai::uint256_union cookie; + nano::uint256_union cookie; std::chrono::steady_clock::time_point created_at; }; @@ -44,93 +44,93 @@ public: class peer_information { public: - peer_information (rai::endpoint const &, unsigned); - peer_information (rai::endpoint const &, std::chrono::steady_clock::time_point const &, std::chrono::steady_clock::time_point const &); - rai::endpoint endpoint; + peer_information (nano::endpoint const &, unsigned); + peer_information (nano::endpoint const &, std::chrono::steady_clock::time_point const &, std::chrono::steady_clock::time_point const &); + nano::endpoint endpoint; boost::asio::ip::address ip_address; std::chrono::steady_clock::time_point last_contact; std::chrono::steady_clock::time_point last_attempt; std::chrono::steady_clock::time_point last_bootstrap_attempt; std::chrono::steady_clock::time_point last_rep_request; std::chrono::steady_clock::time_point last_rep_response; - rai::amount rep_weight; - rai::account probable_rep_account; + nano::amount rep_weight; + nano::account probable_rep_account; unsigned network_version; - boost::optional node_id; + boost::optional node_id; }; /** Manages a set of disovered peers */ class peer_container { public: - peer_container (rai::endpoint const &); + peer_container (nano::endpoint const &); // We were contacted by endpoint, update peers // Returns true if a Node ID handshake should begin - bool contacted (rai::endpoint const &, unsigned); + bool contacted (nano::endpoint const &, unsigned); // Unassigned, reserved, self - bool not_a_peer (rai::endpoint const &, bool); + bool not_a_peer (nano::endpoint const &, bool); // Returns true if peer was already known - bool known_peer (rai::endpoint const &); + bool known_peer (nano::endpoint const &); // Notify of peer we received from - bool insert (rai::endpoint const &, unsigned); - std::unordered_set random_set (size_t); - void random_fill (std::array &); + bool insert (nano::endpoint const &, unsigned); + std::unordered_set random_set (size_t); + void random_fill (std::array &); // Request a list of the top known representatives std::vector representatives (size_t); // List of all peers - std::deque list (); - std::map list_version (); + std::deque list (); + std::map list_version (); std::vector list_vector (size_t); // A list of random peers sized for the configured rebroadcast fanout - std::deque list_fanout (); + std::deque list_fanout (); // Returns a list of probable reps and their weight std::vector list_probable_rep_weights (); // Get the next peer for attempting bootstrap - rai::endpoint bootstrap_peer (); + nano::endpoint bootstrap_peer (); // Purge any peer where last_contact < time_point and return what was left - std::vector purge_list (std::chrono::steady_clock::time_point const &); + std::vector purge_list (std::chrono::steady_clock::time_point const &); void purge_syn_cookies (std::chrono::steady_clock::time_point const &); - std::vector rep_crawl (); - bool rep_response (rai::endpoint const &, rai::account const &, rai::amount const &); - void rep_request (rai::endpoint const &); + std::vector rep_crawl (); + bool rep_response (nano::endpoint const &, nano::account const &, nano::amount const &); + void rep_request (nano::endpoint const &); // Should we reach out to this endpoint with a keepalive message - bool reachout (rai::endpoint const &); + bool reachout (nano::endpoint const &); // Returns boost::none if the IP is rate capped on syn cookie requests, // or if the endpoint already has a syn cookie query - boost::optional assign_syn_cookie (rai::endpoint const &); + boost::optional assign_syn_cookie (nano::endpoint const &); // Returns false if valid, true if invalid (true on error convention) // Also removes the syn cookie from the store if valid - bool validate_syn_cookie (rai::endpoint const &, rai::account, rai::signature); + bool validate_syn_cookie (nano::endpoint const &, nano::account, nano::signature); size_t size (); size_t size_sqrt (); - rai::uint128_t total_weight (); - rai::uint128_t online_weight_minimum; + nano::uint128_t total_weight (); + nano::uint128_t online_weight_minimum; bool empty (); std::mutex mutex; - rai::endpoint self; + nano::endpoint self; boost::multi_index_container< peer_information, boost::multi_index::indexed_by< - boost::multi_index::hashed_unique>, + boost::multi_index::hashed_unique>, boost::multi_index::ordered_non_unique>, boost::multi_index::ordered_non_unique, std::greater>, boost::multi_index::random_access<>, boost::multi_index::ordered_non_unique>, boost::multi_index::ordered_non_unique>, - boost::multi_index::ordered_non_unique, std::greater>, + boost::multi_index::ordered_non_unique, std::greater>, boost::multi_index::ordered_non_unique, boost::multi_index::member>>> peers; boost::multi_index_container< peer_attempt, boost::multi_index::indexed_by< - boost::multi_index::hashed_unique>, + boost::multi_index::hashed_unique>, boost::multi_index::ordered_non_unique>>> attempts; std::mutex syn_cookie_mutex; - std::unordered_map syn_cookies; + std::unordered_map syn_cookies; std::unordered_map syn_cookies_per_ip; // Called when a new peer is observed - std::function peer_observer; + std::function peer_observer; std::function disconnect_observer; // Number of peers to crawl for being a rep every period static size_t constexpr peers_per_crawl = 8; diff --git a/rai/node/plat/posix/openclapi.cpp b/nano/node/plat/posix/openclapi.cpp similarity index 99% rename from rai/node/plat/posix/openclapi.cpp rename to nano/node/plat/posix/openclapi.cpp index 689f82fc..35f78860 100644 --- a/rai/node/plat/posix/openclapi.cpp +++ b/nano/node/plat/posix/openclapi.cpp @@ -1,4 +1,4 @@ -#include +#include #include diff --git a/rai/node/plat/windows/openclapi.cpp b/nano/node/plat/windows/openclapi.cpp similarity index 99% rename from rai/node/plat/windows/openclapi.cpp rename to nano/node/plat/windows/openclapi.cpp index e43ea0ec..8cb8098d 100644 --- a/rai/node/plat/windows/openclapi.cpp +++ b/nano/node/plat/windows/openclapi.cpp @@ -1,4 +1,4 @@ -#include +#include #include diff --git a/rai/node/portmapping.cpp b/nano/node/portmapping.cpp similarity index 91% rename from rai/node/portmapping.cpp rename to nano/node/portmapping.cpp index c169b6ba..28096e4d 100644 --- a/rai/node/portmapping.cpp +++ b/nano/node/portmapping.cpp @@ -1,8 +1,8 @@ -#include -#include +#include +#include #include -rai::port_mapping::port_mapping (rai::node & node_a) : +nano::port_mapping::port_mapping (nano::node & node_a) : node (node_a), devices (nullptr), protocols ({ { { "TCP", 0, boost::asio::ip::address_v4::any (), 0 }, { "UDP", 0, boost::asio::ip::address_v4::any (), 0 } } }), @@ -13,14 +13,14 @@ on (false) data = { { 0 } }; } -void rai::port_mapping::start () +void nano::port_mapping::start () { check_mapping_loop (); } -void rai::port_mapping::refresh_devices () +void nano::port_mapping::refresh_devices () { - if (rai::rai_network != rai::rai_networks::rai_test_network) + if (nano::nano_network != nano::nano_networks::nano_test_network) { std::lock_guard lock (mutex); int discover_error = 0; @@ -48,9 +48,9 @@ void rai::port_mapping::refresh_devices () } } -void rai::port_mapping::refresh_mapping () +void nano::port_mapping::refresh_mapping () { - if (rai::rai_network != rai::rai_networks::rai_test_network) + if (nano::nano_network != nano::nano_networks::nano_test_network) { std::lock_guard lock (mutex); auto node_port (std::to_string (node.network.endpoint ().port ())); @@ -77,10 +77,10 @@ void rai::port_mapping::refresh_mapping () } } -int rai::port_mapping::check_mapping () +int nano::port_mapping::check_mapping () { int result (3600); - if (rai::rai_network != rai::rai_networks::rai_test_network) + if (nano::nano_network != nano::nano_networks::nano_test_network) { // Long discovery time and fast setup/teardown make this impractical for testing std::lock_guard lock (mutex); @@ -122,7 +122,7 @@ int rai::port_mapping::check_mapping () return result; } -void rai::port_mapping::check_mapping_loop () +void nano::port_mapping::check_mapping_loop () { int wait_duration = check_timeout; refresh_devices (); @@ -153,7 +153,7 @@ void rai::port_mapping::check_mapping_loop () } } -void rai::port_mapping::stop () +void nano::port_mapping::stop () { on = false; std::lock_guard lock (mutex); diff --git a/rai/node/portmapping.hpp b/nano/node/portmapping.hpp similarity index 76% rename from rai/node/portmapping.hpp rename to nano/node/portmapping.hpp index 07392489..a8ed3ad8 100644 --- a/rai/node/portmapping.hpp +++ b/nano/node/portmapping.hpp @@ -3,9 +3,9 @@ #include #include #include -#include +#include -namespace rai +namespace nano { class node; @@ -24,7 +24,7 @@ public: class port_mapping { public: - port_mapping (rai::node &); + port_mapping (nano::node &); void start (); void stop (); void refresh_devices (); @@ -36,7 +36,7 @@ private: void check_mapping_loop (); int check_mapping (); std::mutex mutex; - rai::node & node; + nano::node & node; /** List of all UPnP devices */ UPNPDev * devices; /** UPnP collected url information */ @@ -44,8 +44,8 @@ private: /** UPnP state */ IGDdatas data; /** Timeouts are primes so they infrequently happen at the same time */ - static int constexpr mapping_timeout = rai::rai_network == rai::rai_networks::rai_test_network ? 53 : 3593; - static int constexpr check_timeout = rai::rai_network == rai::rai_networks::rai_test_network ? 17 : 53; + static int constexpr mapping_timeout = nano::nano_network == nano::nano_networks::nano_test_network ? 53 : 3593; + static int constexpr check_timeout = nano::nano_network == nano::nano_networks::nano_test_network ? 17 : 53; boost::asio::ip::address_v4 address; std::array protocols; uint64_t check_count; diff --git a/rai/node/rpc.cpp b/nano/node/rpc.cpp similarity index 84% rename from rai/node/rpc.cpp rename to nano/node/rpc.cpp index 738a8fa0..299c6dec 100644 --- a/rai/node/rpc.cpp +++ b/nano/node/rpc.cpp @@ -1,22 +1,22 @@ #include -#include +#include -#include -#include +#include +#include -#ifdef RAIBLOCKS_SECURE_RPC -#include +#ifdef NANO_SECURE_RPC +#include #endif -#include +#include -rai::rpc_secure_config::rpc_secure_config () : +nano::rpc_secure_config::rpc_secure_config () : enable (false), verbose_logging (false) { } -void rai::rpc_secure_config::serialize_json (boost::property_tree::ptree & tree_a) const +void nano::rpc_secure_config::serialize_json (boost::property_tree::ptree & tree_a) const { tree_a.put ("enable", enable); tree_a.put ("verbose_logging", verbose_logging); @@ -27,7 +27,7 @@ void rai::rpc_secure_config::serialize_json (boost::property_tree::ptree & tree_ tree_a.put ("client_certs_path", client_certs_path); } -bool rai::rpc_secure_config::deserialize_json (boost::property_tree::ptree const & tree_a) +bool nano::rpc_secure_config::deserialize_json (boost::property_tree::ptree const & tree_a) { auto error (false); try @@ -47,9 +47,9 @@ bool rai::rpc_secure_config::deserialize_json (boost::property_tree::ptree const return error; } -rai::rpc_config::rpc_config () : +nano::rpc_config::rpc_config () : address (boost::asio::ip::address_v6::loopback ()), -port (rai::rpc::rpc_port), +port (nano::rpc::rpc_port), enable_control (false), frontier_request_limit (16384), chain_request_limit (16384), @@ -57,9 +57,9 @@ max_json_depth (20) { } -rai::rpc_config::rpc_config (bool enable_control_a) : +nano::rpc_config::rpc_config (bool enable_control_a) : address (boost::asio::ip::address_v6::loopback ()), -port (rai::rpc::rpc_port), +port (nano::rpc::rpc_port), enable_control (enable_control_a), frontier_request_limit (16384), chain_request_limit (16384), @@ -67,7 +67,7 @@ max_json_depth (20) { } -void rai::rpc_config::serialize_json (boost::property_tree::ptree & tree_a) const +void nano::rpc_config::serialize_json (boost::property_tree::ptree & tree_a) const { tree_a.put ("address", address.to_string ()); tree_a.put ("port", std::to_string (port)); @@ -77,7 +77,7 @@ void rai::rpc_config::serialize_json (boost::property_tree::ptree & tree_a) cons tree_a.put ("max_json_depth", max_json_depth); } -bool rai::rpc_config::deserialize_json (boost::property_tree::ptree const & tree_a) +bool nano::rpc_config::deserialize_json (boost::property_tree::ptree const & tree_a) { auto result (false); try @@ -122,16 +122,16 @@ bool rai::rpc_config::deserialize_json (boost::property_tree::ptree const & tree return result; } -rai::rpc::rpc (boost::asio::io_context & io_ctx_a, rai::node & node_a, rai::rpc_config const & config_a) : +nano::rpc::rpc (boost::asio::io_context & io_ctx_a, nano::node & node_a, nano::rpc_config const & config_a) : acceptor (io_ctx_a), config (config_a), node (node_a) { } -void rai::rpc::start () +void nano::rpc::start () { - auto endpoint (rai::tcp_endpoint (config.address, config.port)); + auto endpoint (nano::tcp_endpoint (config.address, config.port)); acceptor.open (endpoint.protocol ()); acceptor.set_option (boost::asio::ip::tcp::acceptor::reuse_address (true)); @@ -144,16 +144,16 @@ void rai::rpc::start () } acceptor.listen (); - node.observers.blocks.add ([this](std::shared_ptr block_a, rai::account const & account_a, rai::uint128_t const &, bool) { + node.observers.blocks.add ([this](std::shared_ptr block_a, nano::account const & account_a, nano::uint128_t const &, bool) { observer_action (account_a); }); accept (); } -void rai::rpc::accept () +void nano::rpc::accept () { - auto connection (std::make_shared (node, *this)); + auto connection (std::make_shared (node, *this)); acceptor.async_accept (connection->socket, [this, connection](boost::system::error_code const & ec) { if (acceptor.is_open ()) { @@ -170,12 +170,12 @@ void rai::rpc::accept () }); } -void rai::rpc::stop () +void nano::rpc::stop () { acceptor.close (); } -rai::rpc_handler::rpc_handler (rai::node & node_a, rai::rpc & rpc_a, std::string const & body_a, std::string const & request_id_a, std::function const & response_a) : +nano::rpc_handler::rpc_handler (nano::node & node_a, nano::rpc & rpc_a, std::string const & body_a, std::string const & request_id_a, std::function const & response_a) : body (body_a), request_id (request_id_a), node (node_a), @@ -184,9 +184,9 @@ response (response_a) { } -void rai::rpc::observer_action (rai::account const & account_a) +void nano::rpc::observer_action (nano::account const & account_a) { - std::shared_ptr observer; + std::shared_ptr observer; { std::lock_guard lock (mutex); auto existing (payment_observers.find (account_a)); @@ -201,14 +201,14 @@ void rai::rpc::observer_action (rai::account const & account_a) } } -void rai::error_response (std::function response_a, std::string const & message_a) +void nano::error_response (std::function response_a, std::string const & message_a) { boost::property_tree::ptree response_l; response_l.put ("error", message_a); response_a (response_l); } -void rai::rpc_handler::response_errors () +void nano::rpc_handler::response_errors () { if (ec || response_l.empty ()) { @@ -222,12 +222,12 @@ void rai::rpc_handler::response_errors () } } -std::shared_ptr rai::rpc_handler::wallet_impl () +std::shared_ptr nano::rpc_handler::wallet_impl () { if (!ec) { std::string wallet_text (request.get ("wallet")); - rai::uint256_union wallet; + nano::uint256_union wallet; if (!wallet.decode_hex (wallet_text)) { auto existing (node.wallets.items.find (wallet)); @@ -248,9 +248,9 @@ std::shared_ptr rai::rpc_handler::wallet_impl () return nullptr; } -rai::account rai::rpc_handler::account_impl (std::string account_text) +nano::account nano::rpc_handler::account_impl (std::string account_text) { - rai::account result (0); + nano::account result (0); if (!ec) { if (account_text.empty ()) @@ -265,9 +265,9 @@ rai::account rai::rpc_handler::account_impl (std::string account_text) return result; } -rai::amount rai::rpc_handler::amount_impl () +nano::amount nano::rpc_handler::amount_impl () { - rai::amount result (0); + nano::amount result (0); if (!ec) { std::string amount_text (request.get ("amount")); @@ -279,9 +279,9 @@ rai::amount rai::rpc_handler::amount_impl () return result; } -rai::block_hash rai::rpc_handler::hash_impl (std::string search_text) +nano::block_hash nano::rpc_handler::hash_impl (std::string search_text) { - rai::block_hash result (0); + nano::block_hash result (0); if (!ec) { std::string hash_text (request.get (search_text)); @@ -293,9 +293,9 @@ rai::block_hash rai::rpc_handler::hash_impl (std::string search_text) return result; } -rai::amount rai::rpc_handler::threshold_optional_impl () +nano::amount nano::rpc_handler::threshold_optional_impl () { - rai::amount result (0); + nano::amount result (0); boost::optional threshold_text (request.get_optional ("threshold")); if (!ec && threshold_text.is_initialized ()) { @@ -307,13 +307,13 @@ rai::amount rai::rpc_handler::threshold_optional_impl () return result; } -uint64_t rai::rpc_handler::work_optional_impl () +uint64_t nano::rpc_handler::work_optional_impl () { uint64_t result (0); boost::optional work_text (request.get_optional ("work")); if (!ec && work_text.is_initialized ()) { - if (rai::from_string_hex (work_text.get (), result)) + if (nano::from_string_hex (work_text.get (), result)) { ec = nano::error_common::bad_work_format; } @@ -345,7 +345,7 @@ bool decode_unsigned (std::string const & text, uint64_t & number) } } -uint64_t rai::rpc_handler::count_impl () +uint64_t nano::rpc_handler::count_impl () { uint64_t result (0); if (!ec) @@ -359,7 +359,7 @@ uint64_t rai::rpc_handler::count_impl () return result; } -uint64_t rai::rpc_handler::count_optional_impl (uint64_t result) +uint64_t nano::rpc_handler::count_optional_impl (uint64_t result) { boost::optional count_text (request.get_optional ("count")); if (!ec && count_text.is_initialized ()) @@ -372,7 +372,7 @@ uint64_t rai::rpc_handler::count_optional_impl (uint64_t result) return result; } -bool rai::rpc_handler::rpc_control_impl () +bool nano::rpc_handler::rpc_control_impl () { bool result (false); if (!ec) @@ -389,7 +389,7 @@ bool rai::rpc_handler::rpc_control_impl () return result; } -void rai::rpc_handler::account_balance () +void nano::rpc_handler::account_balance () { auto account (account_impl ()); if (!ec) @@ -401,13 +401,13 @@ void rai::rpc_handler::account_balance () response_errors (); } -void rai::rpc_handler::account_block_count () +void nano::rpc_handler::account_block_count () { auto account (account_impl ()); if (!ec) { auto transaction (node.store.tx_begin_read ()); - rai::account_info info; + nano::account_info info; if (!node.store.account_get (transaction, account, info)) { response_l.put ("block_count", std::to_string (info.block_count)); @@ -420,14 +420,14 @@ void rai::rpc_handler::account_block_count () response_errors (); } -void rai::rpc_handler::account_create () +void nano::rpc_handler::account_create () { rpc_control_impl (); auto wallet (wallet_impl ()); if (!ec) { const bool generate_work = request.get ("work", true); - rai::account new_key (wallet->deterministic_insert (generate_work)); + nano::account new_key (wallet->deterministic_insert (generate_work)); if (!new_key.is_zero ()) { response_l.put ("account", new_key.to_account ()); @@ -440,10 +440,10 @@ void rai::rpc_handler::account_create () response_errors (); } -void rai::rpc_handler::account_get () +void nano::rpc_handler::account_get () { std::string key_text (request.get ("key")); - rai::uint256_union pub; + nano::uint256_union pub; if (!pub.decode_hex (key_text)) { response_l.put ("account", pub.to_account ()); @@ -455,7 +455,7 @@ void rai::rpc_handler::account_get () response_errors (); } -void rai::rpc_handler::account_info () +void nano::rpc_handler::account_info () { auto account (account_impl ()); if (!ec) @@ -464,18 +464,18 @@ void rai::rpc_handler::account_info () const bool weight = request.get ("weight", false); const bool pending = request.get ("pending", false); auto transaction (node.store.tx_begin_read ()); - rai::account_info info; + nano::account_info info; if (!node.store.account_get (transaction, account, info)) { response_l.put ("frontier", info.head.to_string ()); response_l.put ("open_block", info.open_block.to_string ()); response_l.put ("representative_block", info.rep_block.to_string ()); std::string balance; - rai::uint128_union (info.balance).encode_dec (balance); + nano::uint128_union (info.balance).encode_dec (balance); response_l.put ("balance", balance); response_l.put ("modified_timestamp", std::to_string (info.modified)); response_l.put ("block_count", std::to_string (info.block_count)); - response_l.put ("account_version", info.epoch == rai::epoch::epoch_1 ? "1" : "0"); + response_l.put ("account_version", info.epoch == nano::epoch::epoch_1 ? "1" : "0"); if (representative) { auto block (node.store.block_get (transaction, info.rep_block)); @@ -501,7 +501,7 @@ void rai::rpc_handler::account_info () response_errors (); } -void rai::rpc_handler::account_key () +void nano::rpc_handler::account_key () { auto account (account_impl ()); if (!ec) @@ -511,7 +511,7 @@ void rai::rpc_handler::account_key () response_errors (); } -void rai::rpc_handler::account_list () +void nano::rpc_handler::account_list () { auto wallet (wallet_impl ()); if (!ec) @@ -521,7 +521,7 @@ void rai::rpc_handler::account_list () for (auto i (wallet->store.begin (transaction)), j (wallet->store.end ()); i != j; ++i) { boost::property_tree::ptree entry; - entry.put ("", rai::account (i->first).to_account ()); + entry.put ("", nano::account (i->first).to_account ()); accounts.push_back (std::make_pair ("", entry)); } response_l.add_child ("accounts", accounts); @@ -529,7 +529,7 @@ void rai::rpc_handler::account_list () response_errors (); } -void rai::rpc_handler::account_move () +void nano::rpc_handler::account_move () { rpc_control_impl (); auto wallet (wallet_impl ()); @@ -537,17 +537,17 @@ void rai::rpc_handler::account_move () { std::string source_text (request.get ("source")); auto accounts_text (request.get_child ("accounts")); - rai::uint256_union source; + nano::uint256_union source; if (!source.decode_hex (source_text)) { auto existing (node.wallets.items.find (source)); if (existing != node.wallets.items.end ()) { auto source (existing->second); - std::vector accounts; + std::vector accounts; for (auto i (accounts_text.begin ()), n (accounts_text.end ()); i != n; ++i) { - rai::public_key account; + nano::public_key account; account.decode_account (i->second.get ("")); accounts.push_back (account); } @@ -568,7 +568,7 @@ void rai::rpc_handler::account_move () response_errors (); } -void rai::rpc_handler::account_remove () +void nano::rpc_handler::account_remove () { rpc_control_impl (); auto wallet (wallet_impl ()); @@ -596,13 +596,13 @@ void rai::rpc_handler::account_remove () response_errors (); } -void rai::rpc_handler::account_representative () +void nano::rpc_handler::account_representative () { auto account (account_impl ()); if (!ec) { auto transaction (node.store.tx_begin_read ()); - rai::account_info info; + nano::account_info info; if (!node.store.account_get (transaction, account, info)) { auto block (node.store.block_get (transaction, info.rep_block)); @@ -617,7 +617,7 @@ void rai::rpc_handler::account_representative () response_errors (); } -void rai::rpc_handler::account_representative_set () +void nano::rpc_handler::account_representative_set () { rpc_control_impl (); auto wallet (wallet_impl ()); @@ -625,7 +625,7 @@ void rai::rpc_handler::account_representative_set () if (!ec) { std::string representative_text (request.get ("representative")); - rai::account representative; + nano::account representative; if (!representative.decode_account (representative_text)) { auto work (work_optional_impl ()); @@ -634,10 +634,10 @@ void rai::rpc_handler::account_representative_set () auto transaction (node.store.tx_begin_write ()); if (wallet->store.valid_password (transaction)) { - rai::account_info info; + nano::account_info info; if (!node.store.account_get (transaction, account, info)) { - if (!rai::work_validate (info.head, work)) + if (!nano::work_validate (info.head, work)) { wallet->store.work_put (transaction, account, work); } @@ -659,8 +659,8 @@ void rai::rpc_handler::account_representative_set () if (!ec) { auto response_a (response); - wallet->change_async (account, representative, [response_a](std::shared_ptr block) { - rai::block_hash hash (0); + wallet->change_async (account, representative, [response_a](std::shared_ptr block) { + nano::block_hash hash (0); if (block != nullptr) { hash = block->hash (); @@ -684,7 +684,7 @@ void rai::rpc_handler::account_representative_set () } } -void rai::rpc_handler::account_weight () +void nano::rpc_handler::account_weight () { auto account (account_impl ()); if (!ec) @@ -695,7 +695,7 @@ void rai::rpc_handler::account_weight () response_errors (); } -void rai::rpc_handler::accounts_balances () +void nano::rpc_handler::accounts_balances () { boost::property_tree::ptree balances; for (auto & accounts : request.get_child ("accounts")) @@ -714,7 +714,7 @@ void rai::rpc_handler::accounts_balances () response_errors (); } -void rai::rpc_handler::accounts_create () +void nano::rpc_handler::accounts_create () { rpc_control_impl (); auto wallet (wallet_impl ()); @@ -725,7 +725,7 @@ void rai::rpc_handler::accounts_create () boost::property_tree::ptree accounts; for (auto i (0); accounts.size () < count; ++i) { - rai::account new_key (wallet->deterministic_insert (generate_work)); + nano::account new_key (wallet->deterministic_insert (generate_work)); if (!new_key.is_zero ()) { boost::property_tree::ptree entry; @@ -738,7 +738,7 @@ void rai::rpc_handler::accounts_create () response_errors (); } -void rai::rpc_handler::accounts_frontiers () +void nano::rpc_handler::accounts_frontiers () { boost::property_tree::ptree frontiers; auto transaction (node.store.tx_begin_read ()); @@ -758,7 +758,7 @@ void rai::rpc_handler::accounts_frontiers () response_errors (); } -void rai::rpc_handler::accounts_pending () +void nano::rpc_handler::accounts_pending () { auto count (count_optional_impl ()); auto threshold (threshold_optional_impl ()); @@ -772,10 +772,10 @@ void rai::rpc_handler::accounts_pending () if (!ec) { boost::property_tree::ptree peers_l; - for (auto i (node.store.pending_begin (transaction, rai::pending_key (account, 0))); rai::pending_key (i->first).account == account && peers_l.size () < count; ++i) + for (auto i (node.store.pending_begin (transaction, nano::pending_key (account, 0))); nano::pending_key (i->first).account == account && peers_l.size () < count; ++i) { - rai::pending_key key (i->first); - std::shared_ptr block (include_active ? nullptr : node.store.block_get (transaction, key.hash)); + nano::pending_key key (i->first); + std::shared_ptr block (include_active ? nullptr : node.store.block_get (transaction, key.hash)); if (include_active || (block && !node.active.active (*block))) { if (threshold.is_zero () && !source) @@ -786,7 +786,7 @@ void rai::rpc_handler::accounts_pending () } else { - rai::pending_info info (i->second); + nano::pending_info info (i->second); if (info.amount.number () >= threshold.number ()) { if (source) @@ -811,18 +811,18 @@ void rai::rpc_handler::accounts_pending () response_errors (); } -void rai::rpc_handler::available_supply () +void nano::rpc_handler::available_supply () { - auto genesis_balance (node.balance (rai::genesis_account)); // Cold storage genesis - auto landing_balance (node.balance (rai::account ("059F68AAB29DE0D3A27443625C7EA9CDDB6517A8B76FE37727EF6A4D76832AD5"))); // Active unavailable account - auto faucet_balance (node.balance (rai::account ("8E319CE6F3025E5B2DF66DA7AB1467FE48F1679C13DD43BFDB29FA2E9FC40D3B"))); // Faucet account - auto burned_balance ((node.balance_pending (rai::account (0))).second); // Burning 0 account - auto available (rai::genesis_amount - genesis_balance - landing_balance - faucet_balance - burned_balance); + auto genesis_balance (node.balance (nano::genesis_account)); // Cold storage genesis + auto landing_balance (node.balance (nano::account ("059F68AAB29DE0D3A27443625C7EA9CDDB6517A8B76FE37727EF6A4D76832AD5"))); // Active unavailable account + auto faucet_balance (node.balance (nano::account ("8E319CE6F3025E5B2DF66DA7AB1467FE48F1679C13DD43BFDB29FA2E9FC40D3B"))); // Faucet account + auto burned_balance ((node.balance_pending (nano::account (0))).second); // Burning 0 account + auto available (nano::genesis_amount - genesis_balance - landing_balance - faucet_balance - burned_balance); response_l.put ("available", available.convert_to ()); response_errors (); } -void rai::rpc_handler::block () +void nano::rpc_handler::block () { auto hash (hash_impl ()); if (!ec) @@ -843,7 +843,7 @@ void rai::rpc_handler::block () response_errors (); } -void rai::rpc_handler::block_confirm () +void nano::rpc_handler::block_confirm () { auto hash (hash_impl ()); if (!ec) @@ -863,7 +863,7 @@ void rai::rpc_handler::block_confirm () response_errors (); } -void rai::rpc_handler::blocks () +void nano::rpc_handler::blocks () { std::vector hashes; boost::property_tree::ptree blocks; @@ -873,7 +873,7 @@ void rai::rpc_handler::blocks () if (!ec) { std::string hash_text = hashes.second.data (); - rai::uint256_union hash; + nano::uint256_union hash; if (!hash.decode_hex (hash_text)) { auto block (node.store.block_get (transaction, hash)); @@ -898,7 +898,7 @@ void rai::rpc_handler::blocks () response_errors (); } -void rai::rpc_handler::blocks_info () +void nano::rpc_handler::blocks_info () { const bool pending = request.get ("pending", false); const bool source = request.get ("source", false); @@ -911,7 +911,7 @@ void rai::rpc_handler::blocks_info () if (!ec) { std::string hash_text = hashes.second.data (); - rai::uint256_union hash; + nano::uint256_union hash; if (!hash.decode_hex (hash_text)) { auto block (node.store.block_get (transaction, hash)); @@ -931,13 +931,13 @@ void rai::rpc_handler::blocks_info () auto destination (node.ledger.block_destination (transaction, *block)); if (!destination.is_zero ()) { - exists = node.store.pending_exists (transaction, rai::pending_key (destination, hash)); + exists = node.store.pending_exists (transaction, nano::pending_key (destination, hash)); } entry.put ("pending", exists ? "1" : "0"); } if (source) { - rai::block_hash source_hash (node.ledger.block_source (transaction, *block)); + nano::block_hash source_hash (node.ledger.block_source (transaction, *block)); auto block_a (node.store.block_get (transaction, source_hash)); if (block_a != nullptr) { @@ -971,7 +971,7 @@ void rai::rpc_handler::blocks_info () response_errors (); } -void rai::rpc_handler::block_account () +void nano::rpc_handler::block_account () { auto hash (hash_impl ()); if (!ec) @@ -990,7 +990,7 @@ void rai::rpc_handler::block_account () response_errors (); } -void rai::rpc_handler::block_count () +void nano::rpc_handler::block_count () { auto transaction (node.store.tx_begin_read ()); response_l.put ("count", std::to_string (node.store.block_count (transaction).sum ())); @@ -998,10 +998,10 @@ void rai::rpc_handler::block_count () response_errors (); } -void rai::rpc_handler::block_count_type () +void nano::rpc_handler::block_count_type () { auto transaction (node.store.tx_begin_read ()); - rai::block_counts count (node.store.block_count (transaction)); + nano::block_counts count (node.store.block_count (transaction)); response_l.put ("send", std::to_string (count.send)); response_l.put ("receive", std::to_string (count.receive)); response_l.put ("open", std::to_string (count.open)); @@ -1012,13 +1012,13 @@ void rai::rpc_handler::block_count_type () response_errors (); } -void rai::rpc_handler::block_create () +void nano::rpc_handler::block_create () { rpc_control_impl (); if (!ec) { std::string type (request.get ("type")); - rai::uint256_union wallet (0); + nano::uint256_union wallet (0); boost::optional wallet_text (request.get_optional ("wallet")); if (wallet_text.is_initialized ()) { @@ -1027,7 +1027,7 @@ void rai::rpc_handler::block_create () ec = nano::error_common::bad_wallet_number; } } - rai::uint256_union account (0); + nano::uint256_union account (0); boost::optional account_text (request.get_optional ("account")); if (!ec && account_text.is_initialized ()) { @@ -1036,7 +1036,7 @@ void rai::rpc_handler::block_create () ec = nano::error_common::bad_account_number; } } - rai::uint256_union representative (0); + nano::uint256_union representative (0); boost::optional representative_text (request.get_optional ("representative")); if (!ec && representative_text.is_initialized ()) { @@ -1045,7 +1045,7 @@ void rai::rpc_handler::block_create () ec = nano::error_rpc::bad_representative_number; } } - rai::uint256_union destination (0); + nano::uint256_union destination (0); boost::optional destination_text (request.get_optional ("destination")); if (!ec && destination_text.is_initialized ()) { @@ -1054,7 +1054,7 @@ void rai::rpc_handler::block_create () ec = nano::error_rpc::bad_destination; } } - rai::block_hash source (0); + nano::block_hash source (0); boost::optional source_text (request.get_optional ("source")); if (!ec && source_text.is_initialized ()) { @@ -1063,7 +1063,7 @@ void rai::rpc_handler::block_create () ec = nano::error_rpc::bad_source; } } - rai::uint128_union amount (0); + nano::uint128_union amount (0); boost::optional amount_text (request.get_optional ("amount")); if (!ec && amount_text.is_initialized ()) { @@ -1073,10 +1073,10 @@ void rai::rpc_handler::block_create () } } auto work (work_optional_impl ()); - rai::raw_key prv; + nano::raw_key prv; prv.data.clear (); - rai::uint256_union previous (0); - rai::uint128_union balance (0); + nano::uint256_union previous (0); + nano::uint128_union balance (0); if (!ec && wallet != 0 && account != 0) { auto existing (node.wallets.items.find (wallet)); @@ -1130,7 +1130,7 @@ void rai::rpc_handler::block_create () ec = nano::error_rpc::invalid_balance; } } - rai::uint256_union link (0); + nano::uint256_union link (0); boost::optional link_text (request.get_optional ("link")); if (!ec && link_text.is_initialized ()) { @@ -1149,7 +1149,7 @@ void rai::rpc_handler::block_create () } if (prv.data != 0) { - rai::uint256_union pub (rai::pub_key (prv.data)); + nano::uint256_union pub (nano::pub_key (prv.data)); // Fetching account balance & previous for send blocks (if aren't given directly) if (!previous_text.is_initialized () && !balance_text.is_initialized ()) { @@ -1182,7 +1182,7 @@ void rai::rpc_handler::block_create () { work = node.work_generate_blocking (previous.is_zero () ? pub : previous); } - rai::state_block state (pub, previous, representative, balance, link, prv, pub, work); + nano::state_block state (pub, previous, representative, balance, link, prv, pub, work); response_l.put ("hash", state.hash ().to_string ()); std::string contents; state.serialize_json (contents); @@ -1201,7 +1201,7 @@ void rai::rpc_handler::block_create () { work = node.work_generate_blocking (pub); } - rai::open_block open (source, representative, pub, prv, pub, work); + nano::open_block open (source, representative, pub, prv, pub, work); response_l.put ("hash", open.hash ().to_string ()); std::string contents; open.serialize_json (contents); @@ -1220,7 +1220,7 @@ void rai::rpc_handler::block_create () { work = node.work_generate_blocking (previous); } - rai::receive_block receive (previous, source, prv, pub, work); + nano::receive_block receive (previous, source, prv, pub, work); response_l.put ("hash", receive.hash ().to_string ()); std::string contents; receive.serialize_json (contents); @@ -1239,7 +1239,7 @@ void rai::rpc_handler::block_create () { work = node.work_generate_blocking (previous); } - rai::change_block change (previous, representative, prv, pub, work); + nano::change_block change (previous, representative, prv, pub, work); response_l.put ("hash", change.hash ().to_string ()); std::string contents; change.serialize_json (contents); @@ -1260,7 +1260,7 @@ void rai::rpc_handler::block_create () { work = node.work_generate_blocking (previous); } - rai::send_block send (previous, destination, balance.number () - amount.number (), prv, pub, work); + nano::send_block send (previous, destination, balance.number () - amount.number (), prv, pub, work); response_l.put ("hash", send.hash ().to_string ()); std::string contents; send.serialize_json (contents); @@ -1289,7 +1289,7 @@ void rai::rpc_handler::block_create () response_errors (); } -void rai::rpc_handler::block_hash () +void nano::rpc_handler::block_hash () { std::string block_text (request.get ("block")); boost::property_tree::ptree block_l; @@ -1297,7 +1297,7 @@ void rai::rpc_handler::block_hash () boost::property_tree::read_json (block_stream, block_l); block_l.put ("signature", "0"); block_l.put ("work", "0"); - auto block (rai::deserialize_block_json (block_l)); + auto block (nano::deserialize_block_json (block_l)); if (block != nullptr) { response_l.put ("hash", block->hash ().to_string ()); @@ -1309,7 +1309,7 @@ void rai::rpc_handler::block_hash () response_errors (); } -void rai::rpc_handler::bootstrap () +void nano::rpc_handler::bootstrap () { std::string address_text = request.get ("address"); std::string port_text = request.get ("port"); @@ -1318,9 +1318,9 @@ void rai::rpc_handler::bootstrap () if (!address_ec) { uint16_t port; - if (!rai::parse_port (port_text, port)) + if (!nano::parse_port (port_text, port)) { - node.bootstrap_initiator.bootstrap (rai::endpoint (address, port)); + node.bootstrap_initiator.bootstrap (nano::endpoint (address, port)); response_l.put ("success", ""); } else @@ -1335,14 +1335,14 @@ void rai::rpc_handler::bootstrap () response_errors (); } -void rai::rpc_handler::bootstrap_any () +void nano::rpc_handler::bootstrap_any () { node.bootstrap_initiator.bootstrap (); response_l.put ("success", ""); response_errors (); } -void rai::rpc_handler::bootstrap_lazy () +void nano::rpc_handler::bootstrap_lazy () { rpc_control_impl (); auto hash (hash_impl ()); @@ -1358,7 +1358,7 @@ void rai::rpc_handler::bootstrap_lazy () /* * @warning This is an internal/diagnostic RPC, do not rely on its interface being stable */ -void rai::rpc_handler::bootstrap_status () +void nano::rpc_handler::bootstrap_status () { auto attempt (node.bootstrap_initiator.current_attempt ()); if (attempt != nullptr) @@ -1389,7 +1389,7 @@ void rai::rpc_handler::bootstrap_status () response_errors (); } -void rai::rpc_handler::chain (bool successors) +void nano::rpc_handler::chain (bool successors) { auto hash (hash_impl ("block")); auto count (count_impl ()); @@ -1417,7 +1417,7 @@ void rai::rpc_handler::chain (bool successors) response_errors (); } -void rai::rpc_handler::confirmation_active () +void nano::rpc_handler::confirmation_active () { uint64_t announcements (0); boost::optional announcements_text (request.get_optional ("announcements")); @@ -1442,7 +1442,7 @@ void rai::rpc_handler::confirmation_active () response_errors (); } -void rai::rpc_handler::confirmation_history () +void nano::rpc_handler::confirmation_history () { boost::property_tree::ptree elections; boost::property_tree::ptree confirmation_stats; @@ -1470,12 +1470,12 @@ void rai::rpc_handler::confirmation_history () response_errors (); } -void rai::rpc_handler::confirmation_info () +void nano::rpc_handler::confirmation_info () { const bool representatives = request.get ("representatives", false); const bool contents = request.get ("contents", true); std::string root_text (request.get ("root")); - rai::block_hash root; + nano::block_hash root; if (!root.decode_hex (root_text)) { std::lock_guard lock (node.active.mutex); @@ -1484,7 +1484,7 @@ void rai::rpc_handler::confirmation_info () { response_l.put ("announcements", std::to_string (conflict_info->election->announcements)); auto election (conflict_info->election); - rai::uint128_t total (0); + nano::uint128_t total (0); response_l.put ("last_winner", election->status.winner->hash ().to_string ()); auto transaction (node.store.tx_begin_read ()); auto tally_l (election->tally (transaction)); @@ -1503,12 +1503,12 @@ void rai::rpc_handler::confirmation_info () } if (representatives) { - std::multimap> representatives; + std::multimap> representatives; for (auto ii (election->last_votes.begin ()), nn (election->last_votes.end ()); ii != nn; ++ii) { if (i->second->hash () == ii->second.hash) { - rai::account representative (ii->first); + nano::account representative (ii->first); auto amount (node.store.representation_get (transaction, representative)); representatives.insert (std::make_pair (amount, representative)); } @@ -1537,7 +1537,7 @@ void rai::rpc_handler::confirmation_info () response_errors (); } -void rai::rpc_handler::confirmation_quorum () +void nano::rpc_handler::confirmation_quorum () { response_l.put ("quorum_delta", node.delta ().convert_to ()); response_l.put ("online_weight_quorum_percent", std::to_string (node.config.online_weight_quorum)); @@ -1560,7 +1560,7 @@ void rai::rpc_handler::confirmation_quorum () response_errors (); } -void rai::rpc_handler::delegators () +void nano::rpc_handler::delegators () { auto account (account_impl ()); if (!ec) @@ -1569,14 +1569,14 @@ void rai::rpc_handler::delegators () auto transaction (node.store.tx_begin_read ()); for (auto i (node.store.latest_begin (transaction)), n (node.store.latest_end ()); i != n; ++i) { - rai::account_info info (i->second); + nano::account_info info (i->second); auto block (node.store.block_get (transaction, info.rep_block)); assert (block != nullptr); if (block->representative () == account) { std::string balance; - rai::uint128_union (info.balance).encode_dec (balance); - delegators.put (rai::account (i->first).to_account (), balance); + nano::uint128_union (info.balance).encode_dec (balance); + delegators.put (nano::account (i->first).to_account (), balance); } } response_l.add_child ("delegators", delegators); @@ -1584,7 +1584,7 @@ void rai::rpc_handler::delegators () response_errors (); } -void rai::rpc_handler::delegators_count () +void nano::rpc_handler::delegators_count () { auto account (account_impl ()); if (!ec) @@ -1593,7 +1593,7 @@ void rai::rpc_handler::delegators_count () auto transaction (node.store.tx_begin_read ()); for (auto i (node.store.latest_begin (transaction)), n (node.store.latest_end ()); i != n; ++i) { - rai::account_info info (i->second); + nano::account_info info (i->second); auto block (node.store.block_get (transaction, info.rep_block)); assert (block != nullptr); if (block->representative () == account) @@ -1606,19 +1606,19 @@ void rai::rpc_handler::delegators_count () response_errors (); } -void rai::rpc_handler::deterministic_key () +void nano::rpc_handler::deterministic_key () { std::string seed_text (request.get ("seed")); std::string index_text (request.get ("index")); - rai::raw_key seed; + nano::raw_key seed; if (!seed.data.decode_hex (seed_text)) { try { uint32_t index (std::stoul (index_text)); - rai::uint256_union prv; - rai::deterministic_key (seed.data, index, prv); - rai::uint256_union pub (rai::pub_key (prv)); + nano::uint256_union prv; + nano::deterministic_key (seed.data, index, prv); + nano::uint256_union pub (nano::pub_key (prv)); response_l.put ("private", prv.to_string ()); response_l.put ("public", pub.to_string ()); response_l.put ("account", pub.to_account ()); @@ -1635,7 +1635,7 @@ void rai::rpc_handler::deterministic_key () response_errors (); } -void rai::rpc_handler::frontiers () +void nano::rpc_handler::frontiers () { auto start (account_impl ()); auto count (count_impl ()); @@ -1645,14 +1645,14 @@ void rai::rpc_handler::frontiers () auto transaction (node.store.tx_begin_read ()); for (auto i (node.store.latest_begin (transaction, start)), n (node.store.latest_end ()); i != n && frontiers.size () < count; ++i) { - frontiers.put (rai::account (i->first).to_account (), rai::account_info (i->second).head.to_string ()); + frontiers.put (nano::account (i->first).to_account (), nano::account_info (i->second).head.to_string ()); } response_l.add_child ("frontiers", frontiers); } response_errors (); } -void rai::rpc_handler::account_count () +void nano::rpc_handler::account_count () { auto transaction (node.store.tx_begin_read ()); auto size (node.store.account_count (transaction)); @@ -1662,10 +1662,10 @@ void rai::rpc_handler::account_count () namespace { -class history_visitor : public rai::block_visitor +class history_visitor : public nano::block_visitor { public: - history_visitor (rai::rpc_handler & handler_a, bool raw_a, rai::transaction & transaction_a, boost::property_tree::ptree & tree_a, rai::block_hash const & hash_a) : + history_visitor (nano::rpc_handler & handler_a, bool raw_a, nano::transaction & transaction_a, boost::property_tree::ptree & tree_a, nano::block_hash const & hash_a) : handler (handler_a), raw (raw_a), transaction (transaction_a), @@ -1674,7 +1674,7 @@ public: { } virtual ~history_visitor () = default; - void send_block (rai::send_block const & block_a) + void send_block (nano::send_block const & block_a) { tree.put ("type", "send"); auto account (block_a.hashables.destination.to_account ()); @@ -1688,7 +1688,7 @@ public: tree.put ("previous", block_a.hashables.previous.to_string ()); } } - void receive_block (rai::receive_block const & block_a) + void receive_block (nano::receive_block const & block_a) { tree.put ("type", "receive"); auto account (handler.node.ledger.account (transaction, block_a.hashables.source).to_account ()); @@ -1701,7 +1701,7 @@ public: tree.put ("previous", block_a.hashables.previous.to_string ()); } } - void open_block (rai::open_block const & block_a) + void open_block (nano::open_block const & block_a) { if (raw) { @@ -1715,18 +1715,18 @@ public: // Report opens as a receive tree.put ("type", "receive"); } - if (block_a.hashables.source != rai::genesis_account) + if (block_a.hashables.source != nano::genesis_account) { tree.put ("account", handler.node.ledger.account (transaction, block_a.hashables.source).to_account ()); tree.put ("amount", handler.node.ledger.amount (transaction, hash).convert_to ()); } else { - tree.put ("account", rai::genesis_account.to_account ()); - tree.put ("amount", rai::genesis_amount.convert_to ()); + tree.put ("account", nano::genesis_account.to_account ()); + tree.put ("amount", nano::genesis_amount.convert_to ()); } } - void change_block (rai::change_block const & block_a) + void change_block (nano::change_block const & block_a) { if (raw) { @@ -1735,7 +1735,7 @@ public: tree.put ("previous", block_a.hashables.previous.to_string ()); } } - void state_block (rai::state_block const & block_a) + void state_block (nano::state_block const & block_a) { if (raw) { @@ -1792,19 +1792,19 @@ public: } } } - rai::rpc_handler & handler; + nano::rpc_handler & handler; bool raw; - rai::transaction & transaction; + nano::transaction & transaction; boost::property_tree::ptree & tree; - rai::block_hash const & hash; + nano::block_hash const & hash; }; } -void rai::rpc_handler::account_history () +void nano::rpc_handler::account_history () { - rai::account account; + nano::account account; bool output_raw (request.get_optional ("raw") == true); - rai::block_hash hash; + nano::block_hash hash; auto head_str (request.get_optional ("head")); auto transaction (node.store.tx_begin_read ()); if (head_str) @@ -1859,7 +1859,7 @@ void rai::rpc_handler::account_history () entry.put ("hash", hash.to_string ()); if (output_raw) { - entry.put ("work", rai::to_string_hex (block->block_work ())); + entry.put ("work", nano::to_string_hex (block->block_work ())); entry.put ("signature", block->block_signature ().to_string ()); } history.push_back (std::make_pair ("", entry)); @@ -1883,7 +1883,7 @@ void rai::rpc_handler::account_history () response_errors (); } -void rai::rpc_handler::keepalive () +void nano::rpc_handler::keepalive () { rpc_control_impl (); if (!ec) @@ -1891,7 +1891,7 @@ void rai::rpc_handler::keepalive () std::string address_text (request.get ("address")); std::string port_text (request.get ("port")); uint16_t port; - if (!rai::parse_port (port_text, port)) + if (!nano::parse_port (port_text, port)) { node.keepalive (address_text, port); response_l.put ("started", "1"); @@ -1904,22 +1904,22 @@ void rai::rpc_handler::keepalive () response_errors (); } -void rai::rpc_handler::key_create () +void nano::rpc_handler::key_create () { - rai::keypair pair; + nano::keypair pair; response_l.put ("private", pair.prv.data.to_string ()); response_l.put ("public", pair.pub.to_string ()); response_l.put ("account", pair.pub.to_account ()); response_errors (); } -void rai::rpc_handler::key_expand () +void nano::rpc_handler::key_expand () { std::string key_text (request.get ("key")); - rai::uint256_union prv; + nano::uint256_union prv; if (!prv.decode_hex (key_text)) { - rai::uint256_union pub (rai::pub_key (prv)); + nano::uint256_union pub (nano::pub_key (prv)); response_l.put ("private", prv.to_string ()); response_l.put ("public", pub.to_string ()); response_l.put ("account", pub.to_account ()); @@ -1931,13 +1931,13 @@ void rai::rpc_handler::key_expand () response_errors (); } -void rai::rpc_handler::ledger () +void nano::rpc_handler::ledger () { rpc_control_impl (); auto count (count_optional_impl ()); if (!ec) { - rai::account start (0); + nano::account start (0); boost::optional account_text (request.get_optional ("account")); if (account_text.is_initialized ()) { @@ -1962,16 +1962,16 @@ void rai::rpc_handler::ledger () { for (auto i (node.store.latest_begin (transaction, start)), n (node.store.latest_end ()); i != n && accounts.size () < count; ++i) { - rai::account_info info (i->second); + nano::account_info info (i->second); if (info.modified >= modified_since) { - rai::account account (i->first); + nano::account account (i->first); boost::property_tree::ptree response_a; response_a.put ("frontier", info.head.to_string ()); response_a.put ("open_block", info.open_block.to_string ()); response_a.put ("representative_block", info.rep_block.to_string ()); std::string balance; - rai::uint128_union (info.balance).encode_dec (balance); + nano::uint128_union (info.balance).encode_dec (balance); response_a.put ("balance", balance); response_a.put ("modified_timestamp", std::to_string (info.modified)); response_a.put ("block_count", std::to_string (info.block_count)); @@ -1997,23 +1997,23 @@ void rai::rpc_handler::ledger () } else if (!ec) // Sorting { - std::vector> ledger_l; + std::vector> ledger_l; for (auto i (node.store.latest_begin (transaction, start)), n (node.store.latest_end ()); i != n; ++i) { - rai::account_info info (i->second); - rai::uint128_union balance (info.balance); + nano::account_info info (i->second); + nano::uint128_union balance (info.balance); if (info.modified >= modified_since) { - ledger_l.push_back (std::make_pair (balance, rai::account (i->first))); + ledger_l.push_back (std::make_pair (balance, nano::account (i->first))); } } std::sort (ledger_l.begin (), ledger_l.end ()); std::reverse (ledger_l.begin (), ledger_l.end ()); - rai::account_info info; + nano::account_info info; for (auto i (ledger_l.begin ()), n (ledger_l.end ()); i != n && accounts.size () < count; ++i) { node.store.account_get (transaction, i->second, info); - rai::account account (i->second); + nano::account account (i->second); boost::property_tree::ptree response_a; response_a.put ("frontier", info.head.to_string ()); response_a.put ("open_block", info.open_block.to_string ()); @@ -2047,7 +2047,7 @@ void rai::rpc_handler::ledger () response_errors (); } -void rai::rpc_handler::mrai_from_raw (rai::uint128_t ratio) +void nano::rpc_handler::mrai_from_raw (nano::uint128_t ratio) { auto amount (amount_impl ()); if (!ec) @@ -2058,7 +2058,7 @@ void rai::rpc_handler::mrai_from_raw (rai::uint128_t ratio) response_errors (); } -void rai::rpc_handler::mrai_to_raw (rai::uint128_t ratio) +void nano::rpc_handler::mrai_to_raw (nano::uint128_t ratio) { auto amount (amount_impl ()); if (!ec) @@ -2079,7 +2079,7 @@ void rai::rpc_handler::mrai_to_raw (rai::uint128_t ratio) /* * @warning This is an internal/diagnostic RPC, do not rely on its interface being stable */ -void rai::rpc_handler::node_id () +void nano::rpc_handler::node_id () { rpc_control_impl (); if (!ec) @@ -2094,7 +2094,7 @@ void rai::rpc_handler::node_id () /* * @warning This is an internal/diagnostic RPC, do not rely on its interface being stable */ -void rai::rpc_handler::node_id_delete () +void nano::rpc_handler::node_id_delete () { rpc_control_impl (); if (!ec) @@ -2106,7 +2106,7 @@ void rai::rpc_handler::node_id_delete () response_errors (); } -void rai::rpc_handler::password_change () +void nano::rpc_handler::password_change () { rpc_control_impl (); auto wallet (wallet_impl ()); @@ -2120,7 +2120,7 @@ void rai::rpc_handler::password_change () response_errors (); } -void rai::rpc_handler::password_enter () +void nano::rpc_handler::password_enter () { auto wallet (wallet_impl ()); if (!ec) @@ -2133,7 +2133,7 @@ void rai::rpc_handler::password_enter () response_errors (); } -void rai::rpc_handler::password_valid (bool wallet_locked) +void nano::rpc_handler::password_valid (bool wallet_locked) { auto wallet (wallet_impl ()); if (!ec) @@ -2152,7 +2152,7 @@ void rai::rpc_handler::password_valid (bool wallet_locked) response_errors (); } -void rai::rpc_handler::peers () +void nano::rpc_handler::peers () { boost::property_tree::ptree peers_l; auto peers_list (node.peers.list_version ()); @@ -2166,7 +2166,7 @@ void rai::rpc_handler::peers () response_errors (); } -void rai::rpc_handler::pending () +void nano::rpc_handler::pending () { auto account (account_impl ()); auto count (count_optional_impl ()); @@ -2178,10 +2178,10 @@ void rai::rpc_handler::pending () { boost::property_tree::ptree peers_l; auto transaction (node.store.tx_begin_read ()); - for (auto i (node.store.pending_begin (transaction, rai::pending_key (account, 0))); rai::pending_key (i->first).account == account && peers_l.size () < count; ++i) + for (auto i (node.store.pending_begin (transaction, nano::pending_key (account, 0))); nano::pending_key (i->first).account == account && peers_l.size () < count; ++i) { - rai::pending_key key (i->first); - std::shared_ptr block (include_active ? nullptr : node.store.block_get (transaction, key.hash)); + nano::pending_key key (i->first); + std::shared_ptr block (include_active ? nullptr : node.store.block_get (transaction, key.hash)); if (include_active || (block && !node.active.active (*block))) { if (threshold.is_zero () && !source && !min_version) @@ -2192,7 +2192,7 @@ void rai::rpc_handler::pending () } else { - rai::pending_info info (i->second); + nano::pending_info info (i->second); if (info.amount.number () >= threshold.number ()) { if (source || min_version) @@ -2205,7 +2205,7 @@ void rai::rpc_handler::pending () } if (min_version) { - pending_tree.put ("min_version", info.epoch == rai::epoch::epoch_1 ? "1" : "0"); + pending_tree.put ("min_version", info.epoch == nano::epoch::epoch_1 ? "1" : "0"); } peers_l.add_child (key.hash.to_string (), pending_tree); } @@ -2222,7 +2222,7 @@ void rai::rpc_handler::pending () response_errors (); } -void rai::rpc_handler::pending_exists () +void nano::rpc_handler::pending_exists () { auto hash (hash_impl ()); const bool include_active = request.get ("include_active", false); @@ -2236,7 +2236,7 @@ void rai::rpc_handler::pending_exists () auto destination (node.ledger.block_destination (transaction, *block)); if (!destination.is_zero ()) { - exists = node.store.pending_exists (transaction, rai::pending_key (destination, hash)); + exists = node.store.pending_exists (transaction, nano::pending_key (destination, hash)); } exists = exists && (include_active || !node.active.active (*block)); response_l.put ("exists", exists ? "1" : "0"); @@ -2249,20 +2249,20 @@ void rai::rpc_handler::pending_exists () response_errors (); } -void rai::rpc_handler::payment_begin () +void nano::rpc_handler::payment_begin () { std::string id_text (request.get ("wallet")); - rai::uint256_union id; + nano::uint256_union id; if (!id.decode_hex (id_text)) { auto existing (node.wallets.items.find (id)); if (existing != node.wallets.items.end ()) { auto transaction (node.store.tx_begin_write ()); - std::shared_ptr wallet (existing->second); + std::shared_ptr wallet (existing->second); if (wallet->store.valid_password (transaction)) { - rai::account account (0); + nano::account account (0); do { auto existing (wallet->free_accounts.begin ()); @@ -2316,7 +2316,7 @@ void rai::rpc_handler::payment_begin () response_errors (); } -void rai::rpc_handler::payment_init () +void nano::rpc_handler::payment_init () { auto wallet (wallet_impl ()); if (!ec) @@ -2335,7 +2335,7 @@ void rai::rpc_handler::payment_init () response_errors (); } -void rai::rpc_handler::payment_end () +void nano::rpc_handler::payment_end () { auto account (account_impl ()); auto wallet (wallet_impl ()); @@ -2363,7 +2363,7 @@ void rai::rpc_handler::payment_end () response_errors (); } -void rai::rpc_handler::payment_wait () +void nano::rpc_handler::payment_wait () { std::string timeout_text (request.get ("timeout")); auto account (account_impl ()); @@ -2374,7 +2374,7 @@ void rai::rpc_handler::payment_wait () if (!decode_unsigned (timeout_text, timeout)) { { - auto observer (std::make_shared (response, rpc, account, amount)); + auto observer (std::make_shared (response, rpc, account, amount)); observer->start (timeout); std::lock_guard lock (rpc.mutex); assert (rpc.payment_observers.find (account) == rpc.payment_observers.end ()); @@ -2393,73 +2393,73 @@ void rai::rpc_handler::payment_wait () } } -void rai::rpc_handler::process () +void nano::rpc_handler::process () { std::string block_text (request.get ("block")); boost::property_tree::ptree block_l; std::stringstream block_stream (block_text); boost::property_tree::read_json (block_stream, block_l); - std::shared_ptr block (rai::deserialize_block_json (block_l)); + std::shared_ptr block (nano::deserialize_block_json (block_l)); if (block != nullptr) { - if (!rai::work_validate (*block)) + if (!nano::work_validate (*block)) { auto hash (block->hash ()); node.block_arrival.add (hash); - rai::process_return result; + nano::process_return result; { auto transaction (node.store.tx_begin_write ()); result = node.block_processor.process_receive_one (transaction, block, std::chrono::steady_clock::time_point ()); } switch (result.code) { - case rai::process_result::progress: + case nano::process_result::progress: { response_l.put ("hash", hash.to_string ()); break; } - case rai::process_result::gap_previous: + case nano::process_result::gap_previous: { ec = nano::error_process::gap_previous; break; } - case rai::process_result::gap_source: + case nano::process_result::gap_source: { ec = nano::error_process::gap_source; break; } - case rai::process_result::old: + case nano::process_result::old: { ec = nano::error_process::old; break; } - case rai::process_result::bad_signature: + case nano::process_result::bad_signature: { ec = nano::error_process::bad_signature; break; } - case rai::process_result::negative_spend: + case nano::process_result::negative_spend: { // TODO once we get RPC versioning, this should be changed to "negative spend" ec = nano::error_process::negative_spend; break; } - case rai::process_result::balance_mismatch: + case nano::process_result::balance_mismatch: { ec = nano::error_process::balance_mismatch; break; } - case rai::process_result::unreceivable: + case nano::process_result::unreceivable: { ec = nano::error_process::unreceivable; break; } - case rai::process_result::block_position: + case nano::process_result::block_position: { ec = nano::error_process::block_position; break; } - case rai::process_result::fork: + case nano::process_result::fork: { const bool force = request.get ("force", false); if (force && rpc.config.enable_control) @@ -2493,7 +2493,7 @@ void rai::rpc_handler::process () response_errors (); } -void rai::rpc_handler::receive () +void nano::rpc_handler::receive () { rpc_control_impl (); auto wallet (wallet_impl ()); @@ -2509,13 +2509,13 @@ void rai::rpc_handler::receive () auto block (node.store.block_get (transaction, hash)); if (block != nullptr) { - if (node.store.pending_exists (transaction, rai::pending_key (account, hash))) + if (node.store.pending_exists (transaction, nano::pending_key (account, hash))) { auto work (work_optional_impl ()); if (!ec && work) { - rai::account_info info; - rai::uint256_union head; + nano::account_info info; + nano::uint256_union head; if (!node.store.account_get (transaction, account, info)) { head = info.head; @@ -2524,7 +2524,7 @@ void rai::rpc_handler::receive () { head = account; } - if (!rai::work_validate (head, work)) + if (!nano::work_validate (head, work)) { auto transaction_a (node.store.tx_begin_write ()); wallet->store.work_put (transaction_a, account, work); @@ -2537,8 +2537,8 @@ void rai::rpc_handler::receive () if (!ec) { auto response_a (response); - wallet->receive_async (std::move (block), account, rai::genesis_amount, [response_a](std::shared_ptr block_a) { - rai::uint256_union hash_a (0); + wallet->receive_async (std::move (block), account, nano::genesis_amount, [response_a](std::shared_ptr block_a) { + nano::uint256_union hash_a (0); if (block_a != nullptr) { hash_a = block_a->hash (); @@ -2577,7 +2577,7 @@ void rai::rpc_handler::receive () } } -void rai::rpc_handler::receive_minimum () +void nano::rpc_handler::receive_minimum () { rpc_control_impl (); if (!ec) @@ -2587,7 +2587,7 @@ void rai::rpc_handler::receive_minimum () response_errors (); } -void rai::rpc_handler::receive_minimum_set () +void nano::rpc_handler::receive_minimum_set () { rpc_control_impl (); auto amount (amount_impl ()); @@ -2599,7 +2599,7 @@ void rai::rpc_handler::receive_minimum_set () response_errors (); } -void rai::rpc_handler::representatives () +void nano::rpc_handler::representatives () { auto count (count_optional_impl ()); if (!ec) @@ -2611,17 +2611,17 @@ void rai::rpc_handler::representatives () { for (auto i (node.store.representation_begin (transaction)), n (node.store.representation_end ()); i != n && representatives.size () < count; ++i) { - rai::account account (i->first); + nano::account account (i->first); auto amount (node.store.representation_get (transaction, account)); representatives.put (account.to_account (), amount.convert_to ()); } } else // Sorting { - std::vector> representation; + std::vector> representation; for (auto i (node.store.representation_begin (transaction)), n (node.store.representation_end ()); i != n; ++i) { - rai::account account (i->first); + nano::account account (i->first); auto amount (node.store.representation_get (transaction, account)); representation.push_back (std::make_pair (amount, account.to_account ())); } @@ -2637,16 +2637,16 @@ void rai::rpc_handler::representatives () response_errors (); } -void rai::rpc_handler::representatives_online () +void nano::rpc_handler::representatives_online () { const auto accounts_node = request.get_child_optional ("accounts"); const bool weight = request.get ("weight", false); - std::vector accounts_to_filter; + std::vector accounts_to_filter; if (accounts_node.is_initialized ()) { for (auto & a : (*accounts_node)) { - rai::public_key account; + nano::public_key account; auto error (account.decode_account (a.second.get (""))); if (!error) { @@ -2694,7 +2694,7 @@ void rai::rpc_handler::representatives_online () response_errors (); } -void rai::rpc_handler::republish () +void nano::rpc_handler::republish () { auto count (count_optional_impl (1024U)); uint64_t sources (0); @@ -2723,15 +2723,15 @@ void rai::rpc_handler::republish () auto block (node.store.block_get (transaction, hash)); if (block != nullptr) { - std::deque> republish_bundle; + std::deque> republish_bundle; for (auto i (0); !hash.is_zero () && i < count; ++i) { block = node.store.block_get (transaction, hash); if (sources != 0) // Republish source chain { - rai::block_hash source (node.ledger.block_source (transaction, *block)); + nano::block_hash source (node.ledger.block_source (transaction, *block)); auto block_a (node.store.block_get (transaction, source)); - std::vector hashes; + std::vector hashes; while (block_a != nullptr && hashes.size () < sources) { hashes.push_back (source); @@ -2758,12 +2758,12 @@ void rai::rpc_handler::republish () auto destination (node.ledger.block_destination (transaction, *block_b)); if (!destination.is_zero ()) { - if (!node.store.pending_exists (transaction, rai::pending_key (destination, hash))) + if (!node.store.pending_exists (transaction, nano::pending_key (destination, hash))) { - rai::block_hash previous (node.ledger.latest (transaction, destination)); + nano::block_hash previous (node.ledger.latest (transaction, destination)); auto block_d (node.store.block_get (transaction, previous)); - rai::block_hash source; - std::vector hashes; + nano::block_hash source; + std::vector hashes; while (block_d != nullptr && hash != source) { hashes.push_back (previous); @@ -2801,7 +2801,7 @@ void rai::rpc_handler::republish () response_errors (); } -void rai::rpc_handler::search_pending () +void nano::rpc_handler::search_pending () { rpc_control_impl (); auto wallet (wallet_impl ()); @@ -2813,7 +2813,7 @@ void rai::rpc_handler::search_pending () response_errors (); } -void rai::rpc_handler::search_pending_all () +void nano::rpc_handler::search_pending_all () { rpc_control_impl (); if (!ec) @@ -2824,7 +2824,7 @@ void rai::rpc_handler::search_pending_all () response_errors (); } -void rai::rpc_handler::send () +void nano::rpc_handler::send () { rpc_control_impl (); auto wallet (wallet_impl ()); @@ -2837,21 +2837,21 @@ void rai::rpc_handler::send () if (!ec) { std::string source_text (request.get ("source")); - rai::account source; + nano::account source; if (!source.decode_account (source_text)) { std::string destination_text (request.get ("destination")); - rai::account destination; + nano::account destination; if (!destination.decode_account (destination_text)) { auto work (work_optional_impl ()); - rai::uint128_t balance (0); + nano::uint128_t balance (0); if (!ec) { auto transaction (node.store.tx_begin (work != 0)); // false if no "work" in request, true if work > 0 if (wallet->store.valid_password (transaction)) { - rai::account_info info; + nano::account_info info; if (!node.store.account_get (transaction, source, info)) { balance = (info.balance).number (); @@ -2862,7 +2862,7 @@ void rai::rpc_handler::send () } if (!ec && work) { - if (!rai::work_validate (info.head, work)) + if (!nano::work_validate (info.head, work)) { wallet->store.work_put (transaction, source, work); } @@ -2882,10 +2882,10 @@ void rai::rpc_handler::send () boost::optional send_id (request.get_optional ("id")); auto rpc_l (shared_from_this ()); auto response_a (response); - wallet->send_async (source, destination, amount.number (), [balance, amount, response_a](std::shared_ptr block_a) { + wallet->send_async (source, destination, amount.number (), [balance, amount, response_a](std::shared_ptr block_a) { if (block_a != nullptr) { - rai::uint256_union hash (block_a->hash ()); + nano::uint256_union hash (block_a->hash ()); boost::property_tree::ptree response_l; response_l.put ("block", hash.to_string ()); response_a (response_l); @@ -2923,7 +2923,7 @@ void rai::rpc_handler::send () } } -void rai::rpc_handler::stats () +void nano::rpc_handler::stats () { auto sink = node.stats.log_sink_json (); std::string type (request.get ("type", "")); @@ -2949,7 +2949,7 @@ void rai::rpc_handler::stats () } } -void rai::rpc_handler::stop () +void nano::rpc_handler::stop () { rpc_control_impl (); if (!ec) @@ -2964,7 +2964,7 @@ void rai::rpc_handler::stop () } } -void rai::rpc_handler::unchecked () +void nano::rpc_handler::unchecked () { auto count (count_optional_impl ()); if (!ec) @@ -2983,7 +2983,7 @@ void rai::rpc_handler::unchecked () response_errors (); } -void rai::rpc_handler::unchecked_clear () +void nano::rpc_handler::unchecked_clear () { rpc_control_impl (); if (!ec) @@ -2995,7 +2995,7 @@ void rai::rpc_handler::unchecked_clear () response_errors (); } -void rai::rpc_handler::unchecked_get () +void nano::rpc_handler::unchecked_get () { auto hash (hash_impl ()); if (!ec) @@ -3003,7 +3003,7 @@ void rai::rpc_handler::unchecked_get () auto transaction (node.store.tx_begin_read ()); for (auto i (node.store.unchecked_begin (transaction)), n (node.store.unchecked_end ()); i != n; ++i) { - std::shared_ptr block (i->second); + std::shared_ptr block (i->second); if (block->hash () == hash) { std::string contents; @@ -3020,10 +3020,10 @@ void rai::rpc_handler::unchecked_get () response_errors (); } -void rai::rpc_handler::unchecked_keys () +void nano::rpc_handler::unchecked_keys () { auto count (count_optional_impl ()); - rai::uint256_union key (0); + nano::uint256_union key (0); boost::optional hash_text (request.get_optional ("key")); if (!ec && hash_text.is_initialized ()) { @@ -3036,13 +3036,13 @@ void rai::rpc_handler::unchecked_keys () { boost::property_tree::ptree unchecked; auto transaction (node.store.tx_begin_read ()); - for (auto i (node.store.unchecked_begin (transaction, rai::unchecked_key (key, 0))), n (node.store.unchecked_end ()); i != n && unchecked.size () < count; ++i) + for (auto i (node.store.unchecked_begin (transaction, nano::unchecked_key (key, 0))), n (node.store.unchecked_end ()); i != n && unchecked.size () < count; ++i) { boost::property_tree::ptree entry; auto block (i->second); std::string contents; block->serialize_json (contents); - entry.put ("key", rai::block_hash (i->first.key ()).to_string ()); + entry.put ("key", nano::block_hash (i->first.key ()).to_string ()); entry.put ("hash", block->hash ().to_string ()); entry.put ("contents", contents); unchecked.push_back (std::make_pair ("", entry)); @@ -3052,32 +3052,32 @@ void rai::rpc_handler::unchecked_keys () response_errors (); } -void rai::rpc_handler::version () +void nano::rpc_handler::version () { response_l.put ("rpc_version", "1"); response_l.put ("store_version", std::to_string (node.store_version ())); - response_l.put ("protocol_version", std::to_string (rai::protocol_version)); - response_l.put ("node_vendor", boost::str (boost::format ("RaiBlocks %1%.%2%") % RAIBLOCKS_VERSION_MAJOR % RAIBLOCKS_VERSION_MINOR)); + response_l.put ("protocol_version", std::to_string (nano::protocol_version)); + response_l.put ("node_vendor", boost::str (boost::format ("Nano %1%.%2%") % NANO_VERSION_MAJOR % NANO_VERSION_MINOR)); response_errors (); } -void rai::rpc_handler::validate_account_number () +void nano::rpc_handler::validate_account_number () { std::string account_text (request.get ("account")); - rai::uint256_union account; + nano::uint256_union account; auto error (account.decode_account (account_text)); response_l.put ("valid", error ? "0" : "1"); response_errors (); } -void rai::rpc_handler::wallet_add () +void nano::rpc_handler::wallet_add () { rpc_control_impl (); auto wallet (wallet_impl ()); if (!ec) { std::string key_text (request.get ("key")); - rai::raw_key key; + nano::raw_key key; if (!key.data.decode_hex (key_text)) { const bool generate_work = request.get ("work", true); @@ -3099,7 +3099,7 @@ void rai::rpc_handler::wallet_add () response_errors (); } -void rai::rpc_handler::wallet_add_watch () +void nano::rpc_handler::wallet_add_watch () { rpc_control_impl (); auto wallet (wallet_impl ()); @@ -3126,28 +3126,28 @@ void rai::rpc_handler::wallet_add_watch () response_errors (); } -void rai::rpc_handler::wallet_info () +void nano::rpc_handler::wallet_info () { auto wallet (wallet_impl ()); if (!ec) { - rai::uint128_t balance (0); - rai::uint128_t pending (0); + nano::uint128_t balance (0); + nano::uint128_t pending (0); uint64_t count (0); uint64_t deterministic_count (0); uint64_t adhoc_count (0); auto transaction (node.store.tx_begin_read ()); for (auto i (wallet->store.begin (transaction)), n (wallet->store.end ()); i != n; ++i) { - rai::account account (i->first); + nano::account account (i->first); balance = balance + node.ledger.account_balance (transaction, account); pending = pending + node.ledger.account_pending (transaction, account); - rai::key_type key_type (wallet->store.key_type (i->second)); - if (key_type == rai::key_type::deterministic) + nano::key_type key_type (wallet->store.key_type (i->second)); + if (key_type == nano::key_type::deterministic) { deterministic_count++; } - else if (key_type == rai::key_type::adhoc) + else if (key_type == nano::key_type::adhoc) { adhoc_count++; } @@ -3164,7 +3164,7 @@ void rai::rpc_handler::wallet_info () response_errors (); } -void rai::rpc_handler::wallet_balances () +void nano::rpc_handler::wallet_balances () { auto wallet (wallet_impl ()); auto threshold (threshold_optional_impl ()); @@ -3174,12 +3174,12 @@ void rai::rpc_handler::wallet_balances () auto transaction (node.store.tx_begin_read ()); for (auto i (wallet->store.begin (transaction)), n (wallet->store.end ()); i != n; ++i) { - rai::account account (i->first); - rai::uint128_t balance = node.ledger.account_balance (transaction, account); + nano::account account (i->first); + nano::uint128_t balance = node.ledger.account_balance (transaction, account); if (balance >= threshold.number ()) { boost::property_tree::ptree entry; - rai::uint128_t pending = node.ledger.account_pending (transaction, account); + nano::uint128_t pending = node.ledger.account_pending (transaction, account); entry.put ("balance", balance.convert_to ()); entry.put ("pending", pending.convert_to ()); balances.push_back (std::make_pair (account.to_account (), entry)); @@ -3190,14 +3190,14 @@ void rai::rpc_handler::wallet_balances () response_errors (); } -void rai::rpc_handler::wallet_change_seed () +void nano::rpc_handler::wallet_change_seed () { rpc_control_impl (); auto wallet (wallet_impl ()); if (!ec) { std::string seed_text (request.get ("seed")); - rai::raw_key seed; + nano::raw_key seed; if (!seed.data.decode_hex (seed_text)) { auto transaction (node.store.tx_begin_write ()); @@ -3219,7 +3219,7 @@ void rai::rpc_handler::wallet_change_seed () response_errors (); } -void rai::rpc_handler::wallet_contains () +void nano::rpc_handler::wallet_contains () { auto account (account_impl ()); auto wallet (wallet_impl ()); @@ -3232,12 +3232,12 @@ void rai::rpc_handler::wallet_contains () response_errors (); } -void rai::rpc_handler::wallet_create () +void nano::rpc_handler::wallet_create () { rpc_control_impl (); if (!ec) { - rai::keypair wallet_id; + nano::keypair wallet_id; node.wallets.create (wallet_id.pub); auto transaction (node.store.tx_begin_read ()); auto existing (node.wallets.items.find (wallet_id.pub)); @@ -3253,13 +3253,13 @@ void rai::rpc_handler::wallet_create () response_errors (); } -void rai::rpc_handler::wallet_destroy () +void nano::rpc_handler::wallet_destroy () { rpc_control_impl (); if (!ec) { std::string wallet_text (request.get ("wallet")); - rai::uint256_union wallet; + nano::uint256_union wallet; if (!wallet.decode_hex (wallet_text)) { auto existing (node.wallets.items.find (wallet)); @@ -3282,7 +3282,7 @@ void rai::rpc_handler::wallet_destroy () response_errors (); } -void rai::rpc_handler::wallet_export () +void nano::rpc_handler::wallet_export () { auto wallet (wallet_impl ()); if (!ec) @@ -3295,7 +3295,7 @@ void rai::rpc_handler::wallet_export () response_errors (); } -void rai::rpc_handler::wallet_frontiers () +void nano::rpc_handler::wallet_frontiers () { auto wallet (wallet_impl ()); if (!ec) @@ -3304,7 +3304,7 @@ void rai::rpc_handler::wallet_frontiers () auto transaction (node.store.tx_begin_read ()); for (auto i (wallet->store.begin (transaction)), n (wallet->store.end ()); i != n; ++i) { - rai::account account (i->first); + nano::account account (i->first); auto latest (node.ledger.latest (transaction, account)); if (!latest.is_zero ()) { @@ -3316,7 +3316,7 @@ void rai::rpc_handler::wallet_frontiers () response_errors (); } -void rai::rpc_handler::wallet_key_valid () +void nano::rpc_handler::wallet_key_valid () { auto wallet (wallet_impl ()); if (!ec) @@ -3328,7 +3328,7 @@ void rai::rpc_handler::wallet_key_valid () response_errors (); } -void rai::rpc_handler::wallet_ledger () +void nano::rpc_handler::wallet_ledger () { const bool representative = request.get ("representative", false); const bool weight = request.get ("weight", false); @@ -3346,8 +3346,8 @@ void rai::rpc_handler::wallet_ledger () auto transaction (node.store.tx_begin_read ()); for (auto i (wallet->store.begin (transaction)), n (wallet->store.end ()); i != n; ++i) { - rai::account account (i->first); - rai::account_info info; + nano::account account (i->first); + nano::account_info info; if (!node.store.account_get (transaction, account, info)) { if (info.modified >= modified_since) @@ -3357,7 +3357,7 @@ void rai::rpc_handler::wallet_ledger () entry.put ("open_block", info.open_block.to_string ()); entry.put ("representative_block", info.rep_block.to_string ()); std::string balance; - rai::uint128_union (info.balance).encode_dec (balance); + nano::uint128_union (info.balance).encode_dec (balance); entry.put ("balance", balance); entry.put ("modified_timestamp", std::to_string (info.modified)); entry.put ("block_count", std::to_string (info.block_count)); @@ -3386,13 +3386,13 @@ void rai::rpc_handler::wallet_ledger () response_errors (); } -void rai::rpc_handler::wallet_lock () +void nano::rpc_handler::wallet_lock () { rpc_control_impl (); auto wallet (wallet_impl ()); if (!ec) { - rai::raw_key empty; + nano::raw_key empty; empty.data.clear (); wallet->store.password.value_set (empty); response_l.put ("locked", "1"); @@ -3400,7 +3400,7 @@ void rai::rpc_handler::wallet_lock () response_errors (); } -void rai::rpc_handler::wallet_pending () +void nano::rpc_handler::wallet_pending () { auto wallet (wallet_impl ()); auto count (count_optional_impl ()); @@ -3414,12 +3414,12 @@ void rai::rpc_handler::wallet_pending () auto transaction (node.store.tx_begin_read ()); for (auto i (wallet->store.begin (transaction)), n (wallet->store.end ()); i != n; ++i) { - rai::account account (i->first); + nano::account account (i->first); boost::property_tree::ptree peers_l; - for (auto ii (node.store.pending_begin (transaction, rai::pending_key (account, 0))); rai::pending_key (ii->first).account == account && peers_l.size () < count; ++ii) + for (auto ii (node.store.pending_begin (transaction, nano::pending_key (account, 0))); nano::pending_key (ii->first).account == account && peers_l.size () < count; ++ii) { - rai::pending_key key (ii->first); - std::shared_ptr block (include_active ? nullptr : node.store.block_get (transaction, key.hash)); + nano::pending_key key (ii->first); + std::shared_ptr block (include_active ? nullptr : node.store.block_get (transaction, key.hash)); if (include_active || (block && !node.active.active (*block))) { if (threshold.is_zero () && !source) @@ -3430,7 +3430,7 @@ void rai::rpc_handler::wallet_pending () } else { - rai::pending_info info (ii->second); + nano::pending_info info (ii->second); if (info.amount.number () >= threshold.number ()) { if (source || min_version) @@ -3443,7 +3443,7 @@ void rai::rpc_handler::wallet_pending () } if (min_version) { - pending_tree.put ("min_version", info.epoch == rai::epoch::epoch_1 ? "1" : "0"); + pending_tree.put ("min_version", info.epoch == nano::epoch::epoch_1 ? "1" : "0"); } peers_l.add_child (key.hash.to_string (), pending_tree); } @@ -3465,7 +3465,7 @@ void rai::rpc_handler::wallet_pending () response_errors (); } -void rai::rpc_handler::wallet_representative () +void nano::rpc_handler::wallet_representative () { auto wallet (wallet_impl ()); if (!ec) @@ -3476,14 +3476,14 @@ void rai::rpc_handler::wallet_representative () response_errors (); } -void rai::rpc_handler::wallet_representative_set () +void nano::rpc_handler::wallet_representative_set () { rpc_control_impl (); auto wallet (wallet_impl ()); if (!ec) { std::string representative_text (request.get ("representative")); - rai::account representative; + nano::account representative; if (!representative.decode_account (representative_text)) { auto transaction (node.store.tx_begin_write ()); @@ -3498,7 +3498,7 @@ void rai::rpc_handler::wallet_representative_set () response_errors (); } -void rai::rpc_handler::wallet_republish () +void nano::rpc_handler::wallet_republish () { rpc_control_impl (); auto wallet (wallet_impl ()); @@ -3506,14 +3506,14 @@ void rai::rpc_handler::wallet_republish () if (!ec) { boost::property_tree::ptree blocks; - std::deque> republish_bundle; + std::deque> republish_bundle; auto transaction (node.store.tx_begin_read ()); for (auto i (wallet->store.begin (transaction)), n (wallet->store.end ()); i != n; ++i) { - rai::account account (i->first); + nano::account account (i->first); auto latest (node.ledger.latest (transaction, account)); - std::shared_ptr block; - std::vector hashes; + std::shared_ptr block; + std::vector hashes; while (!latest.is_zero () && hashes.size () < count) { hashes.push_back (latest); @@ -3536,7 +3536,7 @@ void rai::rpc_handler::wallet_republish () response_errors (); } -void rai::rpc_handler::wallet_work_get () +void nano::rpc_handler::wallet_work_get () { rpc_control_impl (); auto wallet (wallet_impl ()); @@ -3546,18 +3546,18 @@ void rai::rpc_handler::wallet_work_get () auto transaction (node.store.tx_begin_read ()); for (auto i (wallet->store.begin (transaction)), n (wallet->store.end ()); i != n; ++i) { - rai::account account (i->first); + nano::account account (i->first); uint64_t work (0); auto error_work (wallet->store.work_get (transaction, account, work)); (void)error_work; - works.put (account.to_account (), rai::to_string_hex (work)); + works.put (account.to_account (), nano::to_string_hex (work)); } response_l.add_child ("works", works); } response_errors (); } -void rai::rpc_handler::work_generate () +void nano::rpc_handler::work_generate () { rpc_control_impl (); auto hash (hash_impl ()); @@ -3569,7 +3569,7 @@ void rai::rpc_handler::work_generate () if (work_a) { boost::property_tree::ptree response_l; - response_l.put ("work", rai::to_string_hex (work_a.value ())); + response_l.put ("work", nano::to_string_hex (work_a.value ())); rpc_l->response (response_l); } else @@ -3593,7 +3593,7 @@ void rai::rpc_handler::work_generate () } } -void rai::rpc_handler::work_cancel () +void nano::rpc_handler::work_cancel () { rpc_control_impl (); auto hash (hash_impl ()); @@ -3604,7 +3604,7 @@ void rai::rpc_handler::work_cancel () response_errors (); } -void rai::rpc_handler::work_get () +void nano::rpc_handler::work_get () { rpc_control_impl (); auto wallet (wallet_impl ()); @@ -3617,7 +3617,7 @@ void rai::rpc_handler::work_get () uint64_t work (0); auto error_work (wallet->store.work_get (transaction, account, work)); (void)error_work; - response_l.put ("work", rai::to_string_hex (work)); + response_l.put ("work", nano::to_string_hex (work)); } else { @@ -3627,7 +3627,7 @@ void rai::rpc_handler::work_get () response_errors (); } -void rai::rpc_handler::work_set () +void nano::rpc_handler::work_set () { rpc_control_impl (); auto wallet (wallet_impl ()); @@ -3649,19 +3649,19 @@ void rai::rpc_handler::work_set () response_errors (); } -void rai::rpc_handler::work_validate () +void nano::rpc_handler::work_validate () { auto hash (hash_impl ()); auto work (work_optional_impl ()); if (!ec) { - auto validate (rai::work_validate (hash, work)); + auto validate (nano::work_validate (hash, work)); response_l.put ("valid", validate ? "0" : "1"); } response_errors (); } -void rai::rpc_handler::work_peer_add () +void nano::rpc_handler::work_peer_add () { rpc_control_impl (); if (!ec) @@ -3669,7 +3669,7 @@ void rai::rpc_handler::work_peer_add () std::string address_text = request.get ("address"); std::string port_text = request.get ("port"); uint16_t port; - if (!rai::parse_port (port_text, port)) + if (!nano::parse_port (port_text, port)) { node.config.work_peers.push_back (std::make_pair (address_text, port)); response_l.put ("success", ""); @@ -3682,7 +3682,7 @@ void rai::rpc_handler::work_peer_add () response_errors (); } -void rai::rpc_handler::work_peers () +void nano::rpc_handler::work_peers () { rpc_control_impl (); if (!ec) @@ -3699,7 +3699,7 @@ void rai::rpc_handler::work_peers () response_errors (); } -void rai::rpc_handler::work_peers_clear () +void nano::rpc_handler::work_peers_clear () { rpc_control_impl (); if (!ec) @@ -3710,7 +3710,7 @@ void rai::rpc_handler::work_peers_clear () response_errors (); } -rai::rpc_connection::rpc_connection (rai::node & node_a, rai::rpc & rpc_a) : +nano::rpc_connection::rpc_connection (nano::node & node_a, nano::rpc & rpc_a) : node (node_a.shared ()), rpc (rpc_a), socket (node_a.io_ctx) @@ -3718,12 +3718,12 @@ socket (node_a.io_ctx) responded.clear (); } -void rai::rpc_connection::parse_connection () +void nano::rpc_connection::parse_connection () { read (); } -void rai::rpc_connection::write_result (std::string body, unsigned version) +void nano::rpc_connection::write_result (std::string body, unsigned version) { if (!responded.test_and_set ()) { @@ -3743,7 +3743,7 @@ void rai::rpc_connection::write_result (std::string body, unsigned version) } } -void rai::rpc_connection::read () +void nano::rpc_connection::read () { auto this_l (shared_from_this ()); boost::beast::http::async_read (socket, buffer, request, [this_l](boost::system::error_code const & ec, size_t bytes_transferred) { @@ -3769,7 +3769,7 @@ void rai::rpc_connection::read () }); if (this_l->request.method () == boost::beast::http::verb::post) { - auto handler (std::make_shared (*this_l->node, this_l->rpc, this_l->request.body (), request_id, response_handler)); + auto handler (std::make_shared (*this_l->node, this_l->rpc, this_l->request.body (), request_id, response_handler)); handler->process_request (); } else @@ -3824,7 +3824,7 @@ std::string filter_request (boost::property_tree::ptree tree_a) } } -void rai::rpc_handler::process_request () +void nano::rpc_handler::process_request () { try { @@ -4046,11 +4046,11 @@ void rai::rpc_handler::process_request () } else if (action == "krai_from_raw") { - mrai_from_raw (rai::kxrb_ratio); + mrai_from_raw (nano::kxrb_ratio); } else if (action == "krai_to_raw") { - mrai_to_raw (rai::kxrb_ratio); + mrai_to_raw (nano::kxrb_ratio); } else if (action == "ledger") { @@ -4116,13 +4116,13 @@ void rai::rpc_handler::process_request () { process (); } - else if (action == "rai_from_raw") + else if (action == "nano_from_raw") { - mrai_from_raw (rai::xrb_ratio); + mrai_from_raw (nano::xrb_ratio); } - else if (action == "rai_to_raw") + else if (action == "nano_to_raw") { - mrai_to_raw (rai::xrb_ratio); + mrai_to_raw (nano::xrb_ratio); } else if (action == "receive") { @@ -4325,7 +4325,7 @@ void rai::rpc_handler::process_request () } } -rai::payment_observer::payment_observer (std::function const & response_a, rai::rpc & rpc_a, rai::account const & account_a, rai::amount const & amount_a) : +nano::payment_observer::payment_observer (std::function const & response_a, nano::rpc & rpc_a, nano::account const & account_a, nano::amount const & amount_a) : rpc (rpc_a), account (account_a), amount (amount_a), @@ -4334,27 +4334,27 @@ response (response_a) completed.clear (); } -void rai::payment_observer::start (uint64_t timeout) +void nano::payment_observer::start (uint64_t timeout) { auto this_l (shared_from_this ()); rpc.node.alarm.add (std::chrono::steady_clock::now () + std::chrono::milliseconds (timeout), [this_l]() { - this_l->complete (rai::payment_status::nothing); + this_l->complete (nano::payment_status::nothing); }); } -rai::payment_observer::~payment_observer () +nano::payment_observer::~payment_observer () { } -void rai::payment_observer::observe () +void nano::payment_observer::observe () { if (rpc.node.balance (account) >= amount.number ()) { - complete (rai::payment_status::success); + complete (nano::payment_status::success); } } -void rai::payment_observer::complete (rai::payment_status status) +void nano::payment_observer::complete (nano::payment_status status) { auto already (completed.test_and_set ()); if (!already) @@ -4365,14 +4365,14 @@ void rai::payment_observer::complete (rai::payment_status status) } switch (status) { - case rai::payment_status::nothing: + case nano::payment_status::nothing: { boost::property_tree::ptree response_l; response_l.put ("status", "nothing"); response (response_l); break; } - case rai::payment_status::success: + case nano::payment_status::success: { boost::property_tree::ptree response_l; response_l.put ("status", "success"); @@ -4391,13 +4391,13 @@ void rai::payment_observer::complete (rai::payment_status status) } } -std::unique_ptr rai::get_rpc (boost::asio::io_context & io_ctx_a, rai::node & node_a, rai::rpc_config const & config_a) +std::unique_ptr nano::get_rpc (boost::asio::io_context & io_ctx_a, nano::node & node_a, nano::rpc_config const & config_a) { std::unique_ptr impl; if (config_a.secure.enable) { -#ifdef RAIBLOCKS_SECURE_RPC +#ifdef NANO_SECURE_RPC impl.reset (new rpc_secure (io_ctx_a, node_a, config_a)); #else std::cerr << "RPC configured for TLS, but the node is not compiled with TLS support" << std::endl; diff --git a/rai/node/rpc.hpp b/nano/node/rpc.hpp similarity index 78% rename from rai/node/rpc.hpp rename to nano/node/rpc.hpp index 90f4d0b3..e1b98d9e 100644 --- a/rai/node/rpc.hpp +++ b/nano/node/rpc.hpp @@ -5,10 +5,10 @@ #include #include #include -#include +#include #include -namespace rai +namespace nano { void error_response (std::function response_a, std::string const & message_a); class node; @@ -65,57 +65,57 @@ class payment_observer; class rpc { public: - rpc (boost::asio::io_context &, rai::node &, rai::rpc_config const &); + rpc (boost::asio::io_context &, nano::node &, nano::rpc_config const &); virtual ~rpc () = default; void start (); virtual void accept (); void stop (); - void observer_action (rai::account const &); + void observer_action (nano::account const &); boost::asio::ip::tcp::acceptor acceptor; std::mutex mutex; - std::unordered_map> payment_observers; - rai::rpc_config config; - rai::node & node; + std::unordered_map> payment_observers; + nano::rpc_config config; + nano::node & node; bool on; - static uint16_t const rpc_port = rai::rai_network == rai::rai_networks::rai_live_network ? 7076 : 55000; + static uint16_t const rpc_port = nano::nano_network == nano::nano_networks::nano_live_network ? 7076 : 55000; }; -class rpc_connection : public std::enable_shared_from_this +class rpc_connection : public std::enable_shared_from_this { public: - rpc_connection (rai::node &, rai::rpc &); + rpc_connection (nano::node &, nano::rpc &); virtual ~rpc_connection () = default; virtual void parse_connection (); virtual void read (); virtual void write_result (std::string body, unsigned version); - std::shared_ptr node; - rai::rpc & rpc; + std::shared_ptr node; + nano::rpc & rpc; boost::asio::ip::tcp::socket socket; boost::beast::flat_buffer buffer; boost::beast::http::request request; boost::beast::http::response res; std::atomic_flag responded; }; -class payment_observer : public std::enable_shared_from_this +class payment_observer : public std::enable_shared_from_this { public: - payment_observer (std::function const &, rai::rpc &, rai::account const &, rai::amount const &); + payment_observer (std::function const &, nano::rpc &, nano::account const &, nano::amount const &); ~payment_observer (); void start (uint64_t); void observe (); void timeout (); - void complete (rai::payment_status); + void complete (nano::payment_status); std::mutex mutex; std::condition_variable condition; - rai::rpc & rpc; - rai::account account; - rai::amount amount; + nano::rpc & rpc; + nano::account account; + nano::amount amount; std::function response; std::atomic_flag completed; }; -class rpc_handler : public std::enable_shared_from_this +class rpc_handler : public std::enable_shared_from_this { public: - rpc_handler (rai::node &, rai::rpc &, std::string const &, std::string const &, std::function const &); + rpc_handler (nano::node &, nano::rpc &, std::string const &, std::string const &, std::function const &); void process_request (); void account_balance (); void account_block_count (); @@ -163,8 +163,8 @@ public: void key_create (); void key_expand (); void ledger (); - void mrai_to_raw (rai::uint128_t = rai::Mxrb_ratio); - void mrai_from_raw (rai::uint128_t = rai::Mxrb_ratio); + void mrai_to_raw (nano::uint128_t = nano::Mxrb_ratio); + void mrai_from_raw (nano::uint128_t = nano::Mxrb_ratio); void node_id (); void node_id_delete (); void password_change (); @@ -223,23 +223,23 @@ public: void work_peers_clear (); std::string body; std::string request_id; - rai::node & node; - rai::rpc & rpc; + nano::node & node; + nano::rpc & rpc; boost::property_tree::ptree request; std::function response; void response_errors (); std::error_code ec; boost::property_tree::ptree response_l; - std::shared_ptr wallet_impl (); - rai::account account_impl (std::string = ""); - rai::amount amount_impl (); - rai::block_hash hash_impl (std::string = "hash"); - rai::amount threshold_optional_impl (); + std::shared_ptr wallet_impl (); + nano::account account_impl (std::string = ""); + nano::amount amount_impl (); + nano::block_hash hash_impl (std::string = "hash"); + nano::amount threshold_optional_impl (); uint64_t work_optional_impl (); uint64_t count_impl (); uint64_t count_optional_impl (uint64_t = std::numeric_limits::max ()); bool rpc_control_impl (); }; /** Returns the correct RPC implementation based on TLS configuration */ -std::unique_ptr get_rpc (boost::asio::io_context & io_ctx_a, rai::node & node_a, rai::rpc_config const & config_a); +std::unique_ptr get_rpc (boost::asio::io_context & io_ctx_a, nano::node & node_a, nano::rpc_config const & config_a); } diff --git a/rai/node/rpc_secure.cpp b/nano/node/rpc_secure.cpp similarity index 82% rename from rai/node/rpc_secure.cpp rename to nano/node/rpc_secure.cpp index 16eb89c6..ca4abcdf 100644 --- a/rai/node/rpc_secure.cpp +++ b/nano/node/rpc_secure.cpp @@ -1,7 +1,7 @@ -#include -#include +#include +#include -bool rai::rpc_secure::on_verify_certificate (bool preverified, boost::asio::ssl::verify_context & ctx) +bool nano::rpc_secure::on_verify_certificate (bool preverified, boost::asio::ssl::verify_context & ctx) { X509_STORE_CTX * cts = ctx.native_handle (); auto error (X509_STORE_CTX_get_error (cts)); @@ -56,7 +56,7 @@ bool rai::rpc_secure::on_verify_certificate (bool preverified, boost::asio::ssl: return preverified; } -void rai::rpc_secure::load_certs (boost::asio::ssl::context & context_a) +void nano::rpc_secure::load_certs (boost::asio::ssl::context & context_a) { // This is called if the key is password protected context_a.set_password_callback ( @@ -88,16 +88,16 @@ void rai::rpc_secure::load_certs (boost::asio::ssl::context & context_a) } } -rai::rpc_secure::rpc_secure (boost::asio::io_service & service_a, rai::node & node_a, rai::rpc_config const & config_a) : +nano::rpc_secure::rpc_secure (boost::asio::io_service & service_a, nano::node & node_a, nano::rpc_config const & config_a) : rpc (service_a, node_a, config_a), ssl_context (boost::asio::ssl::context::tlsv12_server) { load_certs (ssl_context); } -void rai::rpc_secure::accept () +void nano::rpc_secure::accept () { - auto connection (std::make_shared (node, *this)); + auto connection (std::make_shared (node, *this)); acceptor.async_accept (connection->socket, [this, connection](boost::system::error_code const & ec) { if (acceptor.is_open ()) { @@ -114,29 +114,29 @@ void rai::rpc_secure::accept () }); } -rai::rpc_connection_secure::rpc_connection_secure (rai::node & node_a, rai::rpc_secure & rpc_a) : -rai::rpc_connection (node_a, rpc_a), +nano::rpc_connection_secure::rpc_connection_secure (nano::node & node_a, nano::rpc_secure & rpc_a) : +nano::rpc_connection (node_a, rpc_a), stream (socket, rpc_a.ssl_context) { } -void rai::rpc_connection_secure::parse_connection () +void nano::rpc_connection_secure::parse_connection () { // Perform the SSL handshake - auto this_l = std::static_pointer_cast (shared_from_this ()); + auto this_l = std::static_pointer_cast (shared_from_this ()); stream.async_handshake (boost::asio::ssl::stream_base::server, [this_l](auto & ec) { this_l->handle_handshake (ec); }); } -void rai::rpc_connection_secure::on_shutdown (const boost::system::error_code & error) +void nano::rpc_connection_secure::on_shutdown (const boost::system::error_code & error) { // No-op. We initiate the shutdown (since the RPC server kills the connection after each request) // and we'll thus get an expected EOF error. If the client disconnects, a short-read error will be expected. } -void rai::rpc_connection_secure::handle_handshake (const boost::system::error_code & error) +void nano::rpc_connection_secure::handle_handshake (const boost::system::error_code & error) { if (!error) { @@ -148,9 +148,9 @@ void rai::rpc_connection_secure::handle_handshake (const boost::system::error_co } } -void rai::rpc_connection_secure::read () +void nano::rpc_connection_secure::read () { - auto this_l (std::static_pointer_cast (shared_from_this ())); + auto this_l (std::static_pointer_cast (shared_from_this ())); boost::beast::http::async_read (stream, buffer, request, [this_l](boost::system::error_code const & ec, size_t bytes_transferred) { if (!ec) { @@ -179,7 +179,7 @@ void rai::rpc_connection_secure::read () if (this_l->request.method () == boost::beast::http::verb::post) { - auto handler (std::make_shared (*this_l->node, this_l->rpc, this_l->request.body (), request_id, response_handler)); + auto handler (std::make_shared (*this_l->node, this_l->rpc, this_l->request.body (), request_id, response_handler)); handler->process_request (); } else diff --git a/rai/node/rpc_secure.hpp b/nano/node/rpc_secure.hpp similarity index 78% rename from rai/node/rpc_secure.hpp rename to nano/node/rpc_secure.hpp index 6c3d20b2..4af5b3ec 100644 --- a/rai/node/rpc_secure.hpp +++ b/nano/node/rpc_secure.hpp @@ -1,17 +1,17 @@ #pragma once #include #include -#include +#include -namespace rai +namespace nano { /** - * Specialization of rai::rpc with TLS support + * Specialization of nano::rpc with TLS support */ class rpc_secure : public rpc { public: - rpc_secure (boost::asio::io_service & service_a, rai::node & node_a, rai::rpc_config const & config_a); + rpc_secure (boost::asio::io_service & service_a, nano::node & node_a, nano::rpc_config const & config_a); /** Starts accepting connections */ void accept () override; @@ -30,13 +30,13 @@ public: }; /** - * Specialization of rai::rpc_connection for establishing TLS connections. + * Specialization of nano::rpc_connection for establishing TLS connections. * Handshakes with client certificates are supported. */ class rpc_connection_secure : public rpc_connection { public: - rpc_connection_secure (rai::node &, rai::rpc_secure &); + rpc_connection_secure (nano::node &, nano::rpc_secure &); void parse_connection () override; void read () override; /** The TLS handshake callback */ diff --git a/rai/node/stats.cpp b/nano/node/stats.cpp similarity index 73% rename from rai/node/stats.cpp rename to nano/node/stats.cpp index e7cbf487..6efd8b2d 100644 --- a/rai/node/stats.cpp +++ b/nano/node/stats.cpp @@ -1,4 +1,4 @@ -#include +#include #include #include @@ -9,7 +9,7 @@ #include #include -bool rai::stat_config::deserialize_json (boost::property_tree::ptree & tree_a) +bool nano::stat_config::deserialize_json (boost::property_tree::ptree & tree_a) { bool error = false; @@ -38,13 +38,13 @@ bool rai::stat_config::deserialize_json (boost::property_tree::ptree & tree_a) return error; } -std::string rai::stat_log_sink::tm_to_string (tm & tm) +std::string nano::stat_log_sink::tm_to_string (tm & tm) { return (boost::format ("%04d.%02d.%02d %02d:%02d:%02d") % (1900 + tm.tm_year) % (tm.tm_mon + 1) % tm.tm_mday % tm.tm_hour % tm.tm_min % tm.tm_sec).str (); } /** JSON sink. The resulting JSON object is provided as both a property_tree::ptree (to_object) and a string (to_string) */ -class json_writer : public rai::stat_log_sink +class json_writer : public nano::stat_log_sink { boost::property_tree::ptree tree; boost::property_tree::ptree entries; @@ -100,7 +100,7 @@ private: }; /** File sink with rotation support */ -class file_writer : public rai::stat_log_sink +class file_writer : public nano::stat_log_sink { public: std::ofstream log; @@ -140,29 +140,29 @@ public: } }; -rai::stat::stat (rai::stat_config config) : +nano::stat::stat (nano::stat_config config) : config (config) { } -std::shared_ptr rai::stat::get_entry (uint32_t key) +std::shared_ptr nano::stat::get_entry (uint32_t key) { return get_entry (key, config.interval, config.capacity); } -std::shared_ptr rai::stat::get_entry (uint32_t key, size_t interval, size_t capacity) +std::shared_ptr nano::stat::get_entry (uint32_t key, size_t interval, size_t capacity) { std::unique_lock lock (stat_mutex); return get_entry_impl (key, interval, capacity); } -std::shared_ptr rai::stat::get_entry_impl (uint32_t key, size_t interval, size_t capacity) +std::shared_ptr nano::stat::get_entry_impl (uint32_t key, size_t interval, size_t capacity) { - std::shared_ptr res; + std::shared_ptr res; auto entry = entries.find (key); if (entry == entries.end ()) { - res = entries.insert (std::make_pair (key, std::make_shared (capacity, interval))).first->second; + res = entries.insert (std::make_pair (key, std::make_shared (capacity, interval))).first->second; } else { @@ -172,23 +172,23 @@ std::shared_ptr rai::stat::get_entry_impl (uint32_t key, size_t return res; } -std::unique_ptr rai::stat::log_sink_json () +std::unique_ptr nano::stat::log_sink_json () { return std::make_unique (); } -std::unique_ptr log_sink_file (std::string filename) +std::unique_ptr log_sink_file (std::string filename) { return std::make_unique (filename); } -void rai::stat::log_counters (stat_log_sink & sink) +void nano::stat::log_counters (stat_log_sink & sink) { std::unique_lock lock (stat_mutex); log_counters_impl (sink); } -void rai::stat::log_counters_impl (stat_log_sink & sink) +void nano::stat::log_counters_impl (stat_log_sink & sink) { sink.begin (); if (sink.entries () >= config.log_rotation_count) @@ -217,13 +217,13 @@ void rai::stat::log_counters_impl (stat_log_sink & sink) sink.finalize (); } -void rai::stat::log_samples (stat_log_sink & sink) +void nano::stat::log_samples (stat_log_sink & sink) { std::unique_lock lock (stat_mutex); log_samples_impl (sink); } -void rai::stat::log_samples_impl (stat_log_sink & sink) +void nano::stat::log_samples_impl (stat_log_sink & sink) { sink.begin (); if (sink.entries () >= config.log_rotation_count) @@ -255,7 +255,7 @@ void rai::stat::log_samples_impl (stat_log_sink & sink) sink.finalize (); } -void rai::stat::update (uint32_t key_a, uint64_t value) +void nano::stat::update (uint32_t key_a, uint64_t value) { static file_writer log_count (config.log_counters_filename); static file_writer log_sample (config.log_samples_filename); @@ -309,192 +309,192 @@ void rai::stat::update (uint32_t key_a, uint64_t value) } } -std::string rai::stat::type_to_string (uint32_t key) +std::string nano::stat::type_to_string (uint32_t key) { auto type = static_cast (key >> 16 & 0x000000ff); std::string res; switch (type) { - case rai::stat::type::block: + case nano::stat::type::block: res = "block"; break; - case rai::stat::type::bootstrap: + case nano::stat::type::bootstrap: res = "bootstrap"; break; - case rai::stat::type::error: + case nano::stat::type::error: res = "error"; break; - case rai::stat::type::http_callback: + case nano::stat::type::http_callback: res = "http_callback"; break; - case rai::stat::type::ledger: + case nano::stat::type::ledger: res = "ledger"; break; - case rai::stat::type::udp: + case nano::stat::type::udp: res = "udp"; break; - case rai::stat::type::peering: + case nano::stat::type::peering: res = "peering"; break; - case rai::stat::type::rollback: + case nano::stat::type::rollback: res = "rollback"; break; - case rai::stat::type::traffic: + case nano::stat::type::traffic: res = "traffic"; break; - case rai::stat::type::traffic_bootstrap: + case nano::stat::type::traffic_bootstrap: res = "traffic_bootstrap"; break; - case rai::stat::type::vote: + case nano::stat::type::vote: res = "vote"; break; - case rai::stat::type::message: + case nano::stat::type::message: res = "message"; break; } return res; } -std::string rai::stat::detail_to_string (uint32_t key) +std::string nano::stat::detail_to_string (uint32_t key) { auto detail = static_cast (key >> 8 & 0x000000ff); std::string res; switch (detail) { - case rai::stat::detail::all: + case nano::stat::detail::all: res = "all"; break; - case rai::stat::detail::bad_sender: + case nano::stat::detail::bad_sender: res = "bad_sender"; break; - case rai::stat::detail::bulk_pull: + case nano::stat::detail::bulk_pull: res = "bulk_pull"; break; - case rai::stat::detail::bulk_pull_account: + case nano::stat::detail::bulk_pull_account: res = "bulk_pull_account"; break; - case rai::stat::detail::bulk_push: + case nano::stat::detail::bulk_push: res = "bulk_push"; break; - case rai::stat::detail::change: + case nano::stat::detail::change: res = "change"; break; - case rai::stat::detail::confirm_ack: + case nano::stat::detail::confirm_ack: res = "confirm_ack"; break; - case rai::stat::detail::node_id_handshake: + case nano::stat::detail::node_id_handshake: res = "node_id_handshake"; break; - case rai::stat::detail::confirm_req: + case nano::stat::detail::confirm_req: res = "confirm_req"; break; - case rai::stat::detail::frontier_req: + case nano::stat::detail::frontier_req: res = "frontier_req"; break; - case rai::stat::detail::handshake: + case nano::stat::detail::handshake: res = "handshake"; break; - case rai::stat::detail::http_callback: + case nano::stat::detail::http_callback: res = "http_callback"; break; - case rai::stat::detail::initiate: + case nano::stat::detail::initiate: res = "initiate"; break; - case rai::stat::detail::initiate_lazy: + case nano::stat::detail::initiate_lazy: res = "initiate_lazy"; break; - case rai::stat::detail::insufficient_work: + case nano::stat::detail::insufficient_work: res = "insufficient_work"; break; - case rai::stat::detail::keepalive: + case nano::stat::detail::keepalive: res = "keepalive"; break; - case rai::stat::detail::open: + case nano::stat::detail::open: res = "open"; break; - case rai::stat::detail::publish: + case nano::stat::detail::publish: res = "publish"; break; - case rai::stat::detail::receive: + case nano::stat::detail::receive: res = "receive"; break; - case rai::stat::detail::republish_vote: + case nano::stat::detail::republish_vote: res = "republish_vote"; break; - case rai::stat::detail::send: + case nano::stat::detail::send: res = "send"; break; - case rai::stat::detail::state_block: + case nano::stat::detail::state_block: res = "state_block"; break; - case rai::stat::detail::epoch_block: + case nano::stat::detail::epoch_block: res = "epoch_block"; break; - case rai::stat::detail::vote_valid: + case nano::stat::detail::vote_valid: res = "vote_valid"; break; - case rai::stat::detail::vote_replay: + case nano::stat::detail::vote_replay: res = "vote_replay"; break; - case rai::stat::detail::vote_invalid: + case nano::stat::detail::vote_invalid: res = "vote_invalid"; break; - case rai::stat::detail::vote_overflow: + case nano::stat::detail::vote_overflow: res = "vote_overflow"; break; - case rai::stat::detail::blocking: + case nano::stat::detail::blocking: res = "blocking"; break; - case rai::stat::detail::overflow: + case nano::stat::detail::overflow: res = "overflow"; break; - case rai::stat::detail::unreachable_host: + case nano::stat::detail::unreachable_host: res = "unreachable_host"; break; - case rai::stat::detail::invalid_magic: + case nano::stat::detail::invalid_magic: res = "invalid_magic"; break; - case rai::stat::detail::invalid_network: + case nano::stat::detail::invalid_network: res = "invalid_network"; break; - case rai::stat::detail::invalid_header: + case nano::stat::detail::invalid_header: res = "invalid_header"; break; - case rai::stat::detail::invalid_message_type: + case nano::stat::detail::invalid_message_type: res = "invalid_message_type"; break; - case rai::stat::detail::invalid_keepalive_message: + case nano::stat::detail::invalid_keepalive_message: res = "invalid_keepalive_message"; break; - case rai::stat::detail::invalid_publish_message: + case nano::stat::detail::invalid_publish_message: res = "invalid_publish_message"; break; - case rai::stat::detail::invalid_confirm_req_message: + case nano::stat::detail::invalid_confirm_req_message: res = "invalid_confirm_req_message"; break; - case rai::stat::detail::invalid_confirm_ack_message: + case nano::stat::detail::invalid_confirm_ack_message: res = "invalid_confirm_ack_message"; break; - case rai::stat::detail::invalid_node_id_handshake_message: + case nano::stat::detail::invalid_node_id_handshake_message: res = "invalid_node_id_handshake_message"; break; - case rai::stat::detail::outdated_version: + case nano::stat::detail::outdated_version: res = "outdated_version"; break; } return res; } -std::string rai::stat::dir_to_string (uint32_t key) +std::string nano::stat::dir_to_string (uint32_t key) { auto dir = static_cast (key & 0x000000ff); std::string res; switch (dir) { - case rai::stat::dir::in: + case nano::stat::dir::in: res = "in"; break; - case rai::stat::dir::out: + case nano::stat::dir::out: res = "out"; break; } diff --git a/rai/node/stats.hpp b/nano/node/stats.hpp similarity index 95% rename from rai/node/stats.hpp rename to nano/node/stats.hpp index c8d60e6c..5f8ede33 100644 --- a/rai/node/stats.hpp +++ b/nano/node/stats.hpp @@ -6,11 +6,11 @@ #include #include #include -#include +#include #include #include -namespace rai +namespace nano { class node; @@ -98,10 +98,10 @@ public: stat_datapoint counter; /** Zero or more observers for samples. Called at the end of the sample interval. */ - rai::observer_set &> sample_observers; + nano::observer_set &> sample_observers; /** Observers for count. Called on each update. */ - rai::observer_set count_observers; + nano::observer_set count_observers; }; /** Log sink interface */ @@ -266,7 +266,7 @@ public: * Initialize stats with a config. * @param config Configuration object; deserialized from config.json */ - stat (rai::stat_config config); + stat (nano::stat_config config); /** * Call this to override the default sample interval and capacity, for a specific stat entry. @@ -402,13 +402,13 @@ private: } /** Get entry for key, creating a new entry if necessary, using interval and sample count from config */ - std::shared_ptr get_entry (uint32_t key); + std::shared_ptr get_entry (uint32_t key); /** Get entry for key, creating a new entry if necessary */ - std::shared_ptr get_entry (uint32_t key, size_t sample_interval, size_t max_samples); + std::shared_ptr get_entry (uint32_t key, size_t sample_interval, size_t max_samples); /** Unlocked implementation of get_entry() */ - std::shared_ptr get_entry_impl (uint32_t key, size_t sample_interval, size_t max_samples); + std::shared_ptr get_entry_impl (uint32_t key, size_t sample_interval, size_t max_samples); /** * Update count and sample and call any observers on the key @@ -424,10 +424,10 @@ private: void log_samples_impl (stat_log_sink & sink); /** Configuration deserialized from config.json */ - rai::stat_config config; + nano::stat_config config; /** Stat entries are sorted by key to simplify processing of log output */ - std::map> entries; + std::map> entries; std::chrono::steady_clock::time_point log_last_count_writeout{ std::chrono::steady_clock::now () }; std::chrono::steady_clock::time_point log_last_sample_writeout{ std::chrono::steady_clock::now () }; diff --git a/rai/node/testing.cpp b/nano/node/testing.cpp similarity index 63% rename from rai/node/testing.cpp rename to nano/node/testing.cpp index cc006971..84df4545 100644 --- a/rai/node/testing.cpp +++ b/nano/node/testing.cpp @@ -1,23 +1,23 @@ #include #include #include -#include -#include +#include +#include -std::string rai::error_system_messages::message (int ev) const +std::string nano::error_system_messages::message (int ev) const { - switch (static_cast (ev)) + switch (static_cast (ev)) { - case rai::error_system::generic: + case nano::error_system::generic: return "Unknown error"; - case rai::error_system::deadline_expired: + case nano::error_system::deadline_expired: return "Deadline expired"; } return "Invalid error code"; } -rai::system::system (uint16_t port_a, size_t count_a) : +nano::system::system (uint16_t port_a, size_t count_a) : alarm (io_ctx), work (1, nullptr) { @@ -26,17 +26,17 @@ work (1, nullptr) { deadline_scaling_factor = std::stod (scale_str); } - logging.init (rai::unique_path ()); + logging.init (nano::unique_path ()); nodes.reserve (count_a); for (size_t i (0); i < count_a; ++i) { - rai::node_init init; - rai::node_config config (port_a + i, logging); - auto node (std::make_shared (init, io_ctx, rai::unique_path (), alarm, config, work)); + nano::node_init init; + nano::node_config config (port_a + i, logging); + auto node (std::make_shared (init, io_ctx, nano::unique_path (), alarm, config, work)); assert (!init.error ()); node->start (); - rai::uint256_union wallet; - rai::random_pool.GenerateBlock (wallet.bytes.data (), wallet.bytes.size ()); + nano::uint256_union wallet; + nano::random_pool.GenerateBlock (wallet.bytes.data (), wallet.bytes.size ()); node->wallets.create (wallet); nodes.push_back (node); } @@ -55,7 +55,7 @@ work (1, nullptr) } while (new1 == starting1 || new2 == starting2); } auto iterations1 (0); - while (std::any_of (nodes.begin (), nodes.end (), [](std::shared_ptr const & node_a) { return node_a->bootstrap_initiator.in_progress (); })) + while (std::any_of (nodes.begin (), nodes.end (), [](std::shared_ptr const & node_a) { return node_a->bootstrap_initiator.in_progress (); })) { poll (); ++iterations1; @@ -63,7 +63,7 @@ work (1, nullptr) } } -rai::system::~system () +nano::system::~system () { for (auto & i : nodes) { @@ -75,11 +75,11 @@ rai::system::~system () // retain the files. if (std::getenv ("TEST_KEEP_TMPDIRS") == nullptr) { - rai::remove_temporary_directories (); + nano::remove_temporary_directories (); } } -std::shared_ptr rai::system::wallet (size_t index_a) +std::shared_ptr nano::system::wallet (size_t index_a) { assert (nodes.size () > index_a); auto size (nodes[index_a]->wallets.items.size ()); @@ -87,29 +87,29 @@ std::shared_ptr rai::system::wallet (size_t index_a) return nodes[index_a]->wallets.items.begin ()->second; } -rai::account rai::system::account (rai::transaction const & transaction_a, size_t index_a) +nano::account nano::system::account (nano::transaction const & transaction_a, size_t index_a) { auto wallet_l (wallet (index_a)); auto keys (wallet_l->store.begin (transaction_a)); assert (keys != wallet_l->store.end ()); auto result (keys->first); assert (++keys == wallet_l->store.end ()); - return rai::account (result); + return nano::account (result); } -void rai::system::deadline_set (std::chrono::duration const & delta_a) +void nano::system::deadline_set (std::chrono::duration const & delta_a) { deadline = std::chrono::steady_clock::now () + delta_a * deadline_scaling_factor; } -std::error_code rai::system::poll (std::chrono::nanoseconds const & wait_time) +std::error_code nano::system::poll (std::chrono::nanoseconds const & wait_time) { std::error_code ec; io_ctx.run_one_for (wait_time); if (std::chrono::steady_clock::now () > deadline) { - ec = rai::error_system::deadline_expired; + ec = nano::error_system::deadline_expired; stop (); } return ec; @@ -120,7 +120,7 @@ namespace class traffic_generator : public std::enable_shared_from_this { public: - traffic_generator (uint32_t count_a, uint32_t wait_a, std::shared_ptr node_a, rai::system & system_a) : + traffic_generator (uint32_t count_a, uint32_t wait_a, std::shared_ptr node_a, nano::system & system_a) : count (count_a), wait (wait_a), node (node_a), @@ -138,15 +138,15 @@ public: node->alarm.add (std::chrono::steady_clock::now () + std::chrono::milliseconds (wait), [this_l]() { this_l->run (); }); } } - std::vector accounts; + std::vector accounts; uint32_t count; uint32_t wait; - std::shared_ptr node; - rai::system & system; + std::shared_ptr node; + nano::system & system; }; } -void rai::system::generate_usage_traffic (uint32_t count_a, uint32_t wait_a) +void nano::system::generate_usage_traffic (uint32_t count_a, uint32_t wait_a) { for (size_t i (0), n (nodes.size ()); i != n; ++i) { @@ -154,7 +154,7 @@ void rai::system::generate_usage_traffic (uint32_t count_a, uint32_t wait_a) } } -void rai::system::generate_usage_traffic (uint32_t count_a, uint32_t wait_a, size_t index_a) +void nano::system::generate_usage_traffic (uint32_t count_a, uint32_t wait_a, size_t index_a) { assert (nodes.size () > index_a); assert (count_a > 0); @@ -162,17 +162,17 @@ void rai::system::generate_usage_traffic (uint32_t count_a, uint32_t wait_a, siz generate->run (); } -void rai::system::generate_rollback (rai::node & node_a, std::vector & accounts_a) +void nano::system::generate_rollback (nano::node & node_a, std::vector & accounts_a) { auto transaction (node_a.store.tx_begin_write ()); auto index (random_pool.GenerateWord32 (0, accounts_a.size () - 1)); auto account (accounts_a[index]); - rai::account_info info; + nano::account_info info; auto error (node_a.store.account_get (transaction, account, info)); if (!error) { auto hash (info.open_block); - rai::genesis genesis; + nano::genesis genesis; if (hash != genesis.hash ()) { accounts_a[index] = accounts_a[accounts_a.size () - 1]; @@ -182,28 +182,28 @@ void rai::system::generate_rollback (rai::node & node_a, std::vector send_block; + std::shared_ptr send_block; { auto transaction (node_a.store.tx_begin_read ()); - rai::uint256_union random_block; + nano::uint256_union random_block; random_pool.GenerateBlock (random_block.bytes.data (), sizeof (random_block.bytes)); - auto i (node_a.store.pending_begin (transaction, rai::pending_key (random_block, 0))); + auto i (node_a.store.pending_begin (transaction, nano::pending_key (random_block, 0))); if (i != node_a.store.pending_end ()) { - rai::pending_key send_hash (i->first); + nano::pending_key send_hash (i->first); send_block = node_a.store.block_get (transaction, send_hash.hash); } } if (send_block != nullptr) { - auto receive_error (wallet (0)->receive_sync (send_block, rai::genesis_account, std::numeric_limits::max ())); + auto receive_error (wallet (0)->receive_sync (send_block, nano::genesis_account, std::numeric_limits::max ())); (void)receive_error; } } -void rai::system::generate_activity (rai::node & node_a, std::vector & accounts_a) +void nano::system::generate_activity (nano::node & node_a, std::vector & accounts_a) { auto what (random_pool.GenerateByte ()); if (what < 0x1) @@ -232,40 +232,40 @@ void rai::system::generate_activity (rai::node & node_a, std::vector & accounts_a) +nano::account nano::system::get_random_account (std::vector & accounts_a) { auto index (random_pool.GenerateWord32 (0, accounts_a.size () - 1)); auto result (accounts_a[index]); return result; } -rai::uint128_t rai::system::get_random_amount (rai::transaction const & transaction_a, rai::node & node_a, rai::account const & account_a) +nano::uint128_t nano::system::get_random_amount (nano::transaction const & transaction_a, nano::node & node_a, nano::account const & account_a) { - rai::uint128_t balance (node_a.ledger.account_balance (transaction_a, account_a)); + nano::uint128_t balance (node_a.ledger.account_balance (transaction_a, account_a)); std::string balance_text (balance.convert_to ()); - rai::uint128_union random_amount; + nano::uint128_union random_amount; random_pool.GenerateBlock (random_amount.bytes.data (), sizeof (random_amount.bytes)); - auto result (((rai::uint256_t{ random_amount.number () } * balance) / rai::uint256_t{ std::numeric_limits::max () }).convert_to ()); + auto result (((nano::uint256_t{ random_amount.number () } * balance) / nano::uint256_t{ std::numeric_limits::max () }).convert_to ()); std::string text (result.convert_to ()); return result; } -void rai::system::generate_send_existing (rai::node & node_a, std::vector & accounts_a) +void nano::system::generate_send_existing (nano::node & node_a, std::vector & accounts_a) { - rai::uint128_t amount; - rai::account destination; - rai::account source; + nano::uint128_t amount; + nano::account destination; + nano::account source; { - rai::account account; + nano::account account; random_pool.GenerateBlock (account.bytes.data (), sizeof (account.bytes)); auto transaction (node_a.store.tx_begin_read ()); - rai::store_iterator entry (node_a.store.latest_begin (transaction, account)); + nano::store_iterator entry (node_a.store.latest_begin (transaction, account)); if (entry == node_a.store.latest_end ()) { entry = node_a.store.latest_begin (transaction); } assert (entry != node_a.store.latest_end ()); - destination = rai::account (entry->first); + destination = nano::account (entry->first); source = get_random_account (accounts_a); amount = get_random_amount (transaction, node_a, source); } @@ -276,34 +276,34 @@ void rai::system::generate_send_existing (rai::node & node_a, std::vector & accounts_a) +void nano::system::generate_change_known (nano::node & node_a, std::vector & accounts_a) { - rai::account source (get_random_account (accounts_a)); + nano::account source (get_random_account (accounts_a)); if (!node_a.latest (source).is_zero ()) { - rai::account destination (get_random_account (accounts_a)); + nano::account destination (get_random_account (accounts_a)); auto change_error (wallet (0)->change_sync (source, destination)); assert (!change_error); } } -void rai::system::generate_change_unknown (rai::node & node_a, std::vector & accounts_a) +void nano::system::generate_change_unknown (nano::node & node_a, std::vector & accounts_a) { - rai::account source (get_random_account (accounts_a)); + nano::account source (get_random_account (accounts_a)); if (!node_a.latest (source).is_zero ()) { - rai::keypair key; - rai::account destination (key.pub); + nano::keypair key; + nano::account destination (key.pub); auto change_error (wallet (0)->change_sync (source, destination)); assert (!change_error); } } -void rai::system::generate_send_new (rai::node & node_a, std::vector & accounts_a) +void nano::system::generate_send_new (nano::node & node_a, std::vector & accounts_a) { assert (node_a.wallets.items.size () == 1); - rai::uint128_t amount; - rai::account source; + nano::uint128_t amount; + nano::account source; { auto transaction (node_a.store.tx_begin_read ()); source = get_random_account (accounts_a); @@ -318,11 +318,11 @@ void rai::system::generate_send_new (rai::node & node_a, std::vector accounts; - wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - accounts.push_back (rai::test_genesis_key.pub); + std::vector accounts; + wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + accounts.push_back (nano::test_genesis_key.pub); auto previous (std::chrono::steady_clock::now ()); for (uint32_t i (0); i < count_a; ++i) { @@ -345,7 +345,7 @@ void rai::system::generate_mass_activity (uint32_t count_a, rai::node & node_a) } } -void rai::system::stop () +void nano::system::stop () { for (auto i : nodes) { @@ -354,11 +354,11 @@ void rai::system::stop () work.stop (); } -rai::landing_store::landing_store () +nano::landing_store::landing_store () { } -rai::landing_store::landing_store (rai::account const & source_a, rai::account const & destination_a, uint64_t start_a, uint64_t last_a) : +nano::landing_store::landing_store (nano::account const & source_a, nano::account const & destination_a, uint64_t start_a, uint64_t last_a) : source (source_a), destination (destination_a), start (start_a), @@ -366,12 +366,12 @@ last (last_a) { } -rai::landing_store::landing_store (bool & error_a, std::istream & stream_a) +nano::landing_store::landing_store (bool & error_a, std::istream & stream_a) { error_a = deserialize (stream_a); } -bool rai::landing_store::deserialize (std::istream & stream_a) +bool nano::landing_store::deserialize (std::istream & stream_a) { bool result; try @@ -404,7 +404,7 @@ bool rai::landing_store::deserialize (std::istream & stream_a) return result; } -void rai::landing_store::serialize (std::ostream & stream_a) const +void nano::landing_store::serialize (std::ostream & stream_a) const { boost::property_tree::ptree tree; tree.put ("source", source.to_account ()); @@ -414,12 +414,12 @@ void rai::landing_store::serialize (std::ostream & stream_a) const boost::property_tree::write_json (stream_a, tree); } -bool rai::landing_store::operator== (rai::landing_store const & other_a) const +bool nano::landing_store::operator== (nano::landing_store const & other_a) const { return source == other_a.source && destination == other_a.destination && start == other_a.start && last == other_a.last; } -rai::landing::landing (rai::node & node_a, std::shared_ptr wallet_a, rai::landing_store & store_a, boost::filesystem::path const & path_a) : +nano::landing::landing (nano::node & node_a, std::shared_ptr wallet_a, nano::landing_store & store_a, boost::filesystem::path const & path_a) : path (path_a), store (store_a), wallet (wallet_a), @@ -427,7 +427,7 @@ node (node_a) { } -void rai::landing::write_store () +void nano::landing::write_store () { std::ofstream store_file; store_file.open (path.string ()); @@ -443,45 +443,45 @@ void rai::landing::write_store () } } -rai::uint128_t rai::landing::distribution_amount (uint64_t interval) +nano::uint128_t nano::landing::distribution_amount (uint64_t interval) { // Halving period ~= Exponent of 2 in seconds approximately 1 year = 2^25 = 33554432 // Interval = Exponent of 2 in seconds approximately 1 minute = 2^10 = 64 uint64_t intervals_per_period (1 << (25 - interval_exponent)); - rai::uint128_t result; + nano::uint128_t result; if (interval < intervals_per_period * 1) { // Total supply / 2^halving period / intervals per period // 2^128 / 2^1 / (2^25 / 2^10) - result = rai::uint128_t (1) << (127 - (25 - interval_exponent)); // 50% + result = nano::uint128_t (1) << (127 - (25 - interval_exponent)); // 50% } else if (interval < intervals_per_period * 2) { - result = rai::uint128_t (1) << (126 - (25 - interval_exponent)); // 25% + result = nano::uint128_t (1) << (126 - (25 - interval_exponent)); // 25% } else if (interval < intervals_per_period * 3) { - result = rai::uint128_t (1) << (125 - (25 - interval_exponent)); // 13% + result = nano::uint128_t (1) << (125 - (25 - interval_exponent)); // 13% } else if (interval < intervals_per_period * 4) { - result = rai::uint128_t (1) << (124 - (25 - interval_exponent)); // 6.3% + result = nano::uint128_t (1) << (124 - (25 - interval_exponent)); // 6.3% } else if (interval < intervals_per_period * 5) { - result = rai::uint128_t (1) << (123 - (25 - interval_exponent)); // 3.1% + result = nano::uint128_t (1) << (123 - (25 - interval_exponent)); // 3.1% } else if (interval < intervals_per_period * 6) { - result = rai::uint128_t (1) << (122 - (25 - interval_exponent)); // 1.6% + result = nano::uint128_t (1) << (122 - (25 - interval_exponent)); // 1.6% } else if (interval < intervals_per_period * 7) { - result = rai::uint128_t (1) << (121 - (25 - interval_exponent)); // 0.8% + result = nano::uint128_t (1) << (121 - (25 - interval_exponent)); // 0.8% } else if (interval < intervals_per_period * 8) { - result = rai::uint128_t (1) << (121 - (25 - interval_exponent)); // 0.8* + result = nano::uint128_t (1) << (121 - (25 - interval_exponent)); // 0.8* } else { @@ -490,10 +490,10 @@ rai::uint128_t rai::landing::distribution_amount (uint64_t interval) return result; } -void rai::landing::distribute_one () +void nano::landing::distribute_one () { - auto now (rai::seconds_since_epoch ()); - rai::block_hash last (1); + auto now (nano::seconds_since_epoch ()); + nano::block_hash last (1); while (!last.is_zero () && store.last + distribution_interval.count () < now) { auto amount (distribution_amount ((store.last - store.start) >> interval_exponent)); @@ -511,12 +511,12 @@ void rai::landing::distribute_one () } } -void rai::landing::distribute_ongoing () +void nano::landing::distribute_ongoing () { distribute_one (); BOOST_LOG (node.log) << "Waiting for next distribution cycle"; node.alarm.add (std::chrono::steady_clock::now () + sleep_seconds, [this]() { distribute_ongoing (); }); } -std::chrono::seconds constexpr rai::landing::distribution_interval; -std::chrono::seconds constexpr rai::landing::sleep_seconds; +std::chrono::seconds constexpr nano::landing::distribution_interval; +std::chrono::seconds constexpr nano::landing::sleep_seconds; diff --git a/nano/node/testing.hpp b/nano/node/testing.hpp new file mode 100644 index 00000000..6a12c061 --- /dev/null +++ b/nano/node/testing.hpp @@ -0,0 +1,80 @@ +#pragma once + +#include +#include +#include + +namespace nano +{ +/** Test-system related error codes */ +enum class error_system +{ + generic = 1, + deadline_expired +}; +class system +{ +public: + system (uint16_t, size_t); + ~system (); + void generate_activity (nano::node &, std::vector &); + void generate_mass_activity (uint32_t, nano::node &); + void generate_usage_traffic (uint32_t, uint32_t, size_t); + void generate_usage_traffic (uint32_t, uint32_t); + nano::account get_random_account (std::vector &); + nano::uint128_t get_random_amount (nano::transaction const &, nano::node &, nano::account const &); + void generate_rollback (nano::node &, std::vector &); + void generate_change_known (nano::node &, std::vector &); + void generate_change_unknown (nano::node &, std::vector &); + void generate_receive (nano::node &); + void generate_send_new (nano::node &, std::vector &); + void generate_send_existing (nano::node &, std::vector &); + std::shared_ptr wallet (size_t); + nano::account account (nano::transaction const &, size_t); + /** + * Polls, sleep if there's no work to be done (default 50ms), then check the deadline + * @returns 0 or nano::deadline_expired + */ + std::error_code poll (const std::chrono::nanoseconds & sleep_time = std::chrono::milliseconds (50)); + void stop (); + void deadline_set (const std::chrono::duration & delta); + boost::asio::io_context io_ctx; + nano::alarm alarm; + std::vector> nodes; + nano::logging logging; + nano::work_pool work; + std::chrono::time_point> deadline{ std::chrono::steady_clock::time_point::max () }; + double deadline_scaling_factor{ 1.0 }; +}; +class landing_store +{ +public: + landing_store (); + landing_store (nano::account const &, nano::account const &, uint64_t, uint64_t); + landing_store (bool &, std::istream &); + nano::account source; + nano::account destination; + uint64_t start; + uint64_t last; + bool deserialize (std::istream &); + void serialize (std::ostream &) const; + bool operator== (nano::landing_store const &) const; +}; +class landing +{ +public: + landing (nano::node &, std::shared_ptr, nano::landing_store &, boost::filesystem::path const &); + void write_store (); + nano::uint128_t distribution_amount (uint64_t); + void distribute_one (); + void distribute_ongoing (); + boost::filesystem::path path; + nano::landing_store & store; + std::shared_ptr wallet; + nano::node & node; + static int constexpr interval_exponent = 10; + static std::chrono::seconds constexpr distribution_interval = std::chrono::seconds (1 << interval_exponent); // 1024 seconds + static std::chrono::seconds constexpr sleep_seconds = std::chrono::seconds (7); +}; +} +REGISTER_ERROR_CODES (nano, error_system); diff --git a/rai/node/voting.cpp b/nano/node/voting.cpp similarity index 75% rename from rai/node/voting.cpp rename to nano/node/voting.cpp index 11965e29..d179fd61 100644 --- a/rai/node/voting.cpp +++ b/nano/node/voting.cpp @@ -1,8 +1,8 @@ -#include +#include -#include +#include -rai::vote_generator::vote_generator (rai::node & node_a, std::chrono::milliseconds wait_a) : +nano::vote_generator::vote_generator (nano::node & node_a, std::chrono::milliseconds wait_a) : node (node_a), wait (wait_a), stopped (false), @@ -16,7 +16,7 @@ thread ([this]() { run (); }) } } -void rai::vote_generator::add (rai::block_hash const & hash_a) +void nano::vote_generator::add (nano::block_hash const & hash_a) { { std::lock_guard lock (mutex); @@ -25,7 +25,7 @@ void rai::vote_generator::add (rai::block_hash const & hash_a) condition.notify_all (); } -void rai::vote_generator::stop () +void nano::vote_generator::stop () { std::unique_lock lock (mutex); stopped = true; @@ -39,9 +39,9 @@ void rai::vote_generator::stop () } } -void rai::vote_generator::send (std::unique_lock & lock_a) +void nano::vote_generator::send (std::unique_lock & lock_a) { - std::vector hashes_l; + std::vector hashes_l; hashes_l.reserve (12); while (!hashes.empty () && hashes_l.size () < 12) { @@ -51,7 +51,7 @@ void rai::vote_generator::send (std::unique_lock & lock_a) lock_a.unlock (); { auto transaction (node.store.tx_begin_read ()); - node.wallets.foreach_representative (transaction, [this, &hashes_l, &transaction](rai::public_key const & pub_a, rai::raw_key const & prv_a) { + node.wallets.foreach_representative (transaction, [this, &hashes_l, &transaction](nano::public_key const & pub_a, nano::raw_key const & prv_a) { auto vote (this->node.store.vote_generate (transaction, pub_a, prv_a, hashes_l)); this->node.vote_processor.vote (vote, this->node.network.endpoint ()); }); @@ -59,9 +59,9 @@ void rai::vote_generator::send (std::unique_lock & lock_a) lock_a.lock (); } -void rai::vote_generator::run () +void nano::vote_generator::run () { - rai::thread_role::set (rai::thread_role::name::voting); + nano::thread_role::set (nano::thread_role::name::voting); std::unique_lock lock (mutex); started = true; lock.unlock (); diff --git a/rai/node/voting.hpp b/nano/node/voting.hpp similarity index 65% rename from rai/node/voting.hpp rename to nano/node/voting.hpp index ad513ae6..73735d2d 100644 --- a/rai/node/voting.hpp +++ b/nano/node/voting.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include #include @@ -8,23 +8,23 @@ #include #include -namespace rai +namespace nano { class node; class vote_generator { public: - vote_generator (rai::node &, std::chrono::milliseconds); - void add (rai::block_hash const &); + vote_generator (nano::node &, std::chrono::milliseconds); + void add (nano::block_hash const &); void stop (); private: void run (); void send (std::unique_lock &); - rai::node & node; + nano::node & node; std::mutex mutex; std::condition_variable condition; - std::deque hashes; + std::deque hashes; std::chrono::milliseconds wait; bool stopped; bool started; diff --git a/rai/node/wallet.cpp b/nano/node/wallet.cpp similarity index 51% rename from rai/node/wallet.cpp rename to nano/node/wallet.cpp index fe8043ab..5ef24ad4 100644 --- a/rai/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -1,9 +1,9 @@ -#include -#include +#include +#include -#include -#include -#include +#include +#include +#include #include @@ -12,100 +12,100 @@ #include -uint64_t const rai::work_pool::publish_threshold; +uint64_t const nano::work_pool::publish_threshold; -rai::uint256_union rai::wallet_store::check (rai::transaction const & transaction_a) +nano::uint256_union nano::wallet_store::check (nano::transaction const & transaction_a) { - rai::wallet_value value (entry_get_raw (transaction_a, rai::wallet_store::check_special)); + nano::wallet_value value (entry_get_raw (transaction_a, nano::wallet_store::check_special)); return value.key; } -rai::uint256_union rai::wallet_store::salt (rai::transaction const & transaction_a) +nano::uint256_union nano::wallet_store::salt (nano::transaction const & transaction_a) { - rai::wallet_value value (entry_get_raw (transaction_a, rai::wallet_store::salt_special)); + nano::wallet_value value (entry_get_raw (transaction_a, nano::wallet_store::salt_special)); return value.key; } -void rai::wallet_store::wallet_key (rai::raw_key & prv_a, rai::transaction const & transaction_a) +void nano::wallet_store::wallet_key (nano::raw_key & prv_a, nano::transaction const & transaction_a) { std::lock_guard lock (mutex); - rai::raw_key wallet_l; + nano::raw_key wallet_l; wallet_key_mem.value (wallet_l); - rai::raw_key password_l; + nano::raw_key password_l; password.value (password_l); prv_a.decrypt (wallet_l.data, password_l, salt (transaction_a).owords[0]); } -void rai::wallet_store::seed (rai::raw_key & prv_a, rai::transaction const & transaction_a) +void nano::wallet_store::seed (nano::raw_key & prv_a, nano::transaction const & transaction_a) { - rai::wallet_value value (entry_get_raw (transaction_a, rai::wallet_store::seed_special)); - rai::raw_key password_l; + nano::wallet_value value (entry_get_raw (transaction_a, nano::wallet_store::seed_special)); + nano::raw_key password_l; wallet_key (password_l, transaction_a); prv_a.decrypt (value.key, password_l, salt (transaction_a).owords[seed_iv_index]); } -void rai::wallet_store::seed_set (rai::transaction const & transaction_a, rai::raw_key const & prv_a) +void nano::wallet_store::seed_set (nano::transaction const & transaction_a, nano::raw_key const & prv_a) { - rai::raw_key password_l; + nano::raw_key password_l; wallet_key (password_l, transaction_a); - rai::uint256_union ciphertext; + nano::uint256_union ciphertext; ciphertext.encrypt (prv_a, password_l, salt (transaction_a).owords[seed_iv_index]); - entry_put_raw (transaction_a, rai::wallet_store::seed_special, rai::wallet_value (ciphertext, 0)); + entry_put_raw (transaction_a, nano::wallet_store::seed_special, nano::wallet_value (ciphertext, 0)); deterministic_clear (transaction_a); } -rai::public_key rai::wallet_store::deterministic_insert (rai::transaction const & transaction_a) +nano::public_key nano::wallet_store::deterministic_insert (nano::transaction const & transaction_a) { auto index (deterministic_index_get (transaction_a)); - rai::raw_key prv; + nano::raw_key prv; deterministic_key (prv, transaction_a, index); - rai::public_key result (rai::pub_key (prv.data)); + nano::public_key result (nano::pub_key (prv.data)); while (exists (transaction_a, result)) { ++index; deterministic_key (prv, transaction_a, index); - result = rai::pub_key (prv.data); + result = nano::pub_key (prv.data); } uint64_t marker (1); marker <<= 32; marker |= index; - entry_put_raw (transaction_a, result, rai::wallet_value (rai::uint256_union (marker), 0)); + entry_put_raw (transaction_a, result, nano::wallet_value (nano::uint256_union (marker), 0)); ++index; deterministic_index_set (transaction_a, index); return result; } -void rai::wallet_store::deterministic_key (rai::raw_key & prv_a, rai::transaction const & transaction_a, uint32_t index_a) +void nano::wallet_store::deterministic_key (nano::raw_key & prv_a, nano::transaction const & transaction_a, uint32_t index_a) { assert (valid_password (transaction_a)); - rai::raw_key seed_l; + nano::raw_key seed_l; seed (seed_l, transaction_a); - rai::deterministic_key (seed_l.data, index_a, prv_a.data); + nano::deterministic_key (seed_l.data, index_a, prv_a.data); } -uint32_t rai::wallet_store::deterministic_index_get (rai::transaction const & transaction_a) +uint32_t nano::wallet_store::deterministic_index_get (nano::transaction const & transaction_a) { - rai::wallet_value value (entry_get_raw (transaction_a, rai::wallet_store::deterministic_index_special)); + nano::wallet_value value (entry_get_raw (transaction_a, nano::wallet_store::deterministic_index_special)); return static_cast (value.key.number () & static_cast (-1)); } -void rai::wallet_store::deterministic_index_set (rai::transaction const & transaction_a, uint32_t index_a) +void nano::wallet_store::deterministic_index_set (nano::transaction const & transaction_a, uint32_t index_a) { - rai::uint256_union index_l (index_a); - rai::wallet_value value (index_l, 0); - entry_put_raw (transaction_a, rai::wallet_store::deterministic_index_special, value); + nano::uint256_union index_l (index_a); + nano::wallet_value value (index_l, 0); + entry_put_raw (transaction_a, nano::wallet_store::deterministic_index_special, value); } -void rai::wallet_store::deterministic_clear (rai::transaction const & transaction_a) +void nano::wallet_store::deterministic_clear (nano::transaction const & transaction_a) { - rai::uint256_union key (0); + nano::uint256_union key (0); for (auto i (begin (transaction_a)), n (end ()); i != n;) { - switch (key_type (rai::wallet_value (i->second))) + switch (key_type (nano::wallet_value (i->second))) { - case rai::key_type::deterministic: + case nano::key_type::deterministic: { - rai::uint256_union key (i->first); + nano::uint256_union key (i->first); erase (transaction_a, key); i = begin (transaction_a, key); break; @@ -120,24 +120,24 @@ void rai::wallet_store::deterministic_clear (rai::transaction const & transactio deterministic_index_set (transaction_a, 0); } -bool rai::wallet_store::valid_password (rai::transaction const & transaction_a) +bool nano::wallet_store::valid_password (nano::transaction const & transaction_a) { - rai::raw_key zero; + nano::raw_key zero; zero.data.clear (); - rai::raw_key wallet_key_l; + nano::raw_key wallet_key_l; wallet_key (wallet_key_l, transaction_a); - rai::uint256_union check_l; + nano::uint256_union check_l; check_l.encrypt (zero, wallet_key_l, salt (transaction_a).owords[check_iv_index]); bool ok = check (transaction_a) == check_l; return ok; } -bool rai::wallet_store::attempt_password (rai::transaction const & transaction_a, std::string const & password_a) +bool nano::wallet_store::attempt_password (nano::transaction const & transaction_a, std::string const & password_a) { bool result = false; { std::lock_guard lock (mutex); - rai::raw_key password_l; + nano::raw_key password_l; derive_key (password_l, transaction_a, password_a); password.value_set (password_l); result = !valid_password (transaction_a); @@ -161,25 +161,25 @@ bool rai::wallet_store::attempt_password (rai::transaction const & transaction_a return result; } -bool rai::wallet_store::rekey (rai::transaction const & transaction_a, std::string const & password_a) +bool nano::wallet_store::rekey (nano::transaction const & transaction_a, std::string const & password_a) { std::lock_guard lock (mutex); bool result (false); if (valid_password (transaction_a)) { - rai::raw_key password_new; + nano::raw_key password_new; derive_key (password_new, transaction_a, password_a); - rai::raw_key wallet_key_l; + nano::raw_key wallet_key_l; wallet_key (wallet_key_l, transaction_a); - rai::raw_key password_l; + nano::raw_key password_l; password.value (password_l); password.value_set (password_new); - rai::uint256_union encrypted; + nano::uint256_union encrypted; encrypted.encrypt (wallet_key_l, password_new, salt (transaction_a).owords[0]); - rai::raw_key wallet_enc; + nano::raw_key wallet_enc; wallet_enc.data = encrypted; wallet_key_mem.value_set (wallet_enc); - entry_put_raw (transaction_a, rai::wallet_store::wallet_key_special, rai::wallet_value (encrypted, 0)); + entry_put_raw (transaction_a, nano::wallet_store::wallet_key_special, nano::wallet_value (encrypted, 0)); } else { @@ -188,18 +188,18 @@ bool rai::wallet_store::rekey (rai::transaction const & transaction_a, std::stri return result; } -void rai::wallet_store::derive_key (rai::raw_key & prv_a, rai::transaction const & transaction_a, std::string const & password_a) +void nano::wallet_store::derive_key (nano::raw_key & prv_a, nano::transaction const & transaction_a, std::string const & password_a) { auto salt_l (salt (transaction_a)); kdf.phs (prv_a, password_a, salt_l); } -rai::fan::fan (rai::uint256_union const & key, size_t count_a) +nano::fan::fan (nano::uint256_union const & key, size_t count_a) { - std::unique_ptr first (new rai::uint256_union (key)); + std::unique_ptr first (new nano::uint256_union (key)); for (auto i (1); i < count_a; ++i) { - std::unique_ptr entry (new rai::uint256_union); + std::unique_ptr entry (new nano::uint256_union); random_pool.GenerateBlock (entry->bytes.data (), entry->bytes.size ()); *first ^= *entry; values.push_back (std::move (entry)); @@ -207,13 +207,13 @@ rai::fan::fan (rai::uint256_union const & key, size_t count_a) values.push_back (std::move (first)); } -void rai::fan::value (rai::raw_key & prv_a) +void nano::fan::value (nano::raw_key & prv_a) { std::lock_guard lock (mutex); value_get (prv_a); } -void rai::fan::value_get (rai::raw_key & prv_a) +void nano::fan::value_get (nano::raw_key & prv_a) { assert (!mutex.try_lock ()); prv_a.data.clear (); @@ -223,34 +223,34 @@ void rai::fan::value_get (rai::raw_key & prv_a) } } -void rai::fan::value_set (rai::raw_key const & value_a) +void nano::fan::value_set (nano::raw_key const & value_a) { std::lock_guard lock (mutex); - rai::raw_key value_l; + nano::raw_key value_l; value_get (value_l); *(values[0]) ^= value_l.data; *(values[0]) ^= value_a.data; } // Wallet version number -rai::uint256_union const rai::wallet_store::version_special (0); +nano::uint256_union const nano::wallet_store::version_special (0); // Random number used to salt private key encryption -rai::uint256_union const rai::wallet_store::salt_special (1); +nano::uint256_union const nano::wallet_store::salt_special (1); // Key used to encrypt wallet keys, encrypted itself by the user password -rai::uint256_union const rai::wallet_store::wallet_key_special (2); +nano::uint256_union const nano::wallet_store::wallet_key_special (2); // Check value used to see if password is valid -rai::uint256_union const rai::wallet_store::check_special (3); +nano::uint256_union const nano::wallet_store::check_special (3); // Representative account to be used if we open a new account -rai::uint256_union const rai::wallet_store::representative_special (4); +nano::uint256_union const nano::wallet_store::representative_special (4); // Wallet seed for deterministic key generation -rai::uint256_union const rai::wallet_store::seed_special (5); +nano::uint256_union const nano::wallet_store::seed_special (5); // Current key index for deterministic keys -rai::uint256_union const rai::wallet_store::deterministic_index_special (6); -int const rai::wallet_store::special_count (7); -size_t const rai::wallet_store::check_iv_index (0); -size_t const rai::wallet_store::seed_iv_index (1); +nano::uint256_union const nano::wallet_store::deterministic_index_special (6); +int const nano::wallet_store::special_count (7); +size_t const nano::wallet_store::check_iv_index (0); +size_t const nano::wallet_store::seed_iv_index (1); -rai::wallet_store::wallet_store (bool & init_a, rai::kdf & kdf_a, rai::transaction & transaction_a, rai::account representative_a, unsigned fanout_a, std::string const & wallet_a, std::string const & json_a) : +nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, nano::transaction & transaction_a, nano::account representative_a, unsigned fanout_a, std::string const & wallet_a, std::string const & json_a) : password (0, fanout_a), wallet_key_mem (0, fanout_a), kdf (kdf_a) @@ -260,7 +260,7 @@ kdf (kdf_a) if (!init_a) { MDB_val junk; - assert (mdb_get (tx (transaction_a), handle, rai::mdb_val (version_special), &junk) == MDB_NOTFOUND); + assert (mdb_get (tx (transaction_a), handle, nano::mdb_val (version_special), &junk) == MDB_NOTFOUND); boost::property_tree::ptree wallet_l; std::stringstream istream (json_a); try @@ -273,15 +273,15 @@ kdf (kdf_a) } for (auto i (wallet_l.begin ()), n (wallet_l.end ()); i != n; ++i) { - rai::uint256_union key; + nano::uint256_union key; init_a = key.decode_hex (i->first); if (!init_a) { - rai::uint256_union value; + nano::uint256_union value; init_a = value.decode_hex (wallet_l.get (i->first)); if (!init_a) { - entry_put_raw (transaction_a, key, rai::wallet_value (value, 0)); + entry_put_raw (transaction_a, key, nano::wallet_value (value, 0)); } else { @@ -293,20 +293,20 @@ kdf (kdf_a) init_a = true; } } - init_a |= mdb_get (tx (transaction_a), handle, rai::mdb_val (version_special), &junk) != 0; - init_a |= mdb_get (tx (transaction_a), handle, rai::mdb_val (wallet_key_special), &junk) != 0; - init_a |= mdb_get (tx (transaction_a), handle, rai::mdb_val (salt_special), &junk) != 0; - init_a |= mdb_get (tx (transaction_a), handle, rai::mdb_val (check_special), &junk) != 0; - init_a |= mdb_get (tx (transaction_a), handle, rai::mdb_val (representative_special), &junk) != 0; - rai::raw_key key; + init_a |= mdb_get (tx (transaction_a), handle, nano::mdb_val (version_special), &junk) != 0; + init_a |= mdb_get (tx (transaction_a), handle, nano::mdb_val (wallet_key_special), &junk) != 0; + init_a |= mdb_get (tx (transaction_a), handle, nano::mdb_val (salt_special), &junk) != 0; + init_a |= mdb_get (tx (transaction_a), handle, nano::mdb_val (check_special), &junk) != 0; + init_a |= mdb_get (tx (transaction_a), handle, nano::mdb_val (representative_special), &junk) != 0; + nano::raw_key key; key.data.clear (); password.value_set (key); - key.data = entry_get_raw (transaction_a, rai::wallet_store::wallet_key_special).key; + key.data = entry_get_raw (transaction_a, nano::wallet_store::wallet_key_special).key; wallet_key_mem.value_set (key); } } -rai::wallet_store::wallet_store (bool & init_a, rai::kdf & kdf_a, rai::transaction & transaction_a, rai::account representative_a, unsigned fanout_a, std::string const & wallet_a) : +nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, nano::transaction & transaction_a, nano::account representative_a, unsigned fanout_a, std::string const & wallet_a) : password (0, fanout_a), wallet_key_mem (0, fanout_a), kdf (kdf_a) @@ -317,55 +317,55 @@ kdf (kdf_a) { int version_status; MDB_val version_value; - version_status = mdb_get (tx (transaction_a), handle, rai::mdb_val (version_special), &version_value); + version_status = mdb_get (tx (transaction_a), handle, nano::mdb_val (version_special), &version_value); if (version_status == MDB_NOTFOUND) { version_put (transaction_a, version_current); - rai::uint256_union salt_l; + nano::uint256_union salt_l; random_pool.GenerateBlock (salt_l.bytes.data (), salt_l.bytes.size ()); - entry_put_raw (transaction_a, rai::wallet_store::salt_special, rai::wallet_value (salt_l, 0)); + entry_put_raw (transaction_a, nano::wallet_store::salt_special, nano::wallet_value (salt_l, 0)); // Wallet key is a fixed random key that encrypts all entries - rai::raw_key wallet_key; + nano::raw_key wallet_key; random_pool.GenerateBlock (wallet_key.data.bytes.data (), sizeof (wallet_key.data.bytes)); - rai::raw_key password_l; + nano::raw_key password_l; password_l.data.clear (); password.value_set (password_l); - rai::raw_key zero; + nano::raw_key zero; zero.data.clear (); // Wallet key is encrypted by the user's password - rai::uint256_union encrypted; + nano::uint256_union encrypted; encrypted.encrypt (wallet_key, zero, salt_l.owords[0]); - entry_put_raw (transaction_a, rai::wallet_store::wallet_key_special, rai::wallet_value (encrypted, 0)); - rai::raw_key wallet_key_enc; + entry_put_raw (transaction_a, nano::wallet_store::wallet_key_special, nano::wallet_value (encrypted, 0)); + nano::raw_key wallet_key_enc; wallet_key_enc.data = encrypted; wallet_key_mem.value_set (wallet_key_enc); - rai::uint256_union check; + nano::uint256_union check; check.encrypt (zero, wallet_key, salt_l.owords[check_iv_index]); - entry_put_raw (transaction_a, rai::wallet_store::check_special, rai::wallet_value (check, 0)); - entry_put_raw (transaction_a, rai::wallet_store::representative_special, rai::wallet_value (representative_a, 0)); - rai::raw_key seed; + entry_put_raw (transaction_a, nano::wallet_store::check_special, nano::wallet_value (check, 0)); + entry_put_raw (transaction_a, nano::wallet_store::representative_special, nano::wallet_value (representative_a, 0)); + nano::raw_key seed; random_pool.GenerateBlock (seed.data.bytes.data (), seed.data.bytes.size ()); seed_set (transaction_a, seed); - entry_put_raw (transaction_a, rai::wallet_store::deterministic_index_special, rai::wallet_value (rai::uint256_union (0), 0)); + entry_put_raw (transaction_a, nano::wallet_store::deterministic_index_special, nano::wallet_value (nano::uint256_union (0), 0)); } } - rai::raw_key key; - key.data = entry_get_raw (transaction_a, rai::wallet_store::wallet_key_special).key; + nano::raw_key key; + key.data = entry_get_raw (transaction_a, nano::wallet_store::wallet_key_special).key; wallet_key_mem.value_set (key); } -std::vector rai::wallet_store::accounts (rai::transaction const & transaction_a) +std::vector nano::wallet_store::accounts (nano::transaction const & transaction_a) { - std::vector result; + std::vector result; for (auto i (begin (transaction_a)), n (end ()); i != n; ++i) { - rai::account account (i->first); + nano::account account (i->first); result.push_back (account); } return result; } -void rai::wallet_store::initialize (rai::transaction const & transaction_a, bool & init_a, std::string const & path_a) +void nano::wallet_store::initialize (nano::transaction const & transaction_a, bool & init_a, std::string const & path_a) { assert (strlen (path_a.c_str ()) == path_a.size ()); auto error (0); @@ -373,53 +373,53 @@ void rai::wallet_store::initialize (rai::transaction const & transaction_a, bool init_a = error != 0; } -bool rai::wallet_store::is_representative (rai::transaction const & transaction_a) +bool nano::wallet_store::is_representative (nano::transaction const & transaction_a) { return exists (transaction_a, representative (transaction_a)); } -void rai::wallet_store::representative_set (rai::transaction const & transaction_a, rai::account const & representative_a) +void nano::wallet_store::representative_set (nano::transaction const & transaction_a, nano::account const & representative_a) { - entry_put_raw (transaction_a, rai::wallet_store::representative_special, rai::wallet_value (representative_a, 0)); + entry_put_raw (transaction_a, nano::wallet_store::representative_special, nano::wallet_value (representative_a, 0)); } -rai::account rai::wallet_store::representative (rai::transaction const & transaction_a) +nano::account nano::wallet_store::representative (nano::transaction const & transaction_a) { - rai::wallet_value value (entry_get_raw (transaction_a, rai::wallet_store::representative_special)); + nano::wallet_value value (entry_get_raw (transaction_a, nano::wallet_store::representative_special)); return value.key; } -rai::public_key rai::wallet_store::insert_adhoc (rai::transaction const & transaction_a, rai::raw_key const & prv) +nano::public_key nano::wallet_store::insert_adhoc (nano::transaction const & transaction_a, nano::raw_key const & prv) { assert (valid_password (transaction_a)); - rai::public_key pub (rai::pub_key (prv.data)); - rai::raw_key password_l; + nano::public_key pub (nano::pub_key (prv.data)); + nano::raw_key password_l; wallet_key (password_l, transaction_a); - rai::uint256_union ciphertext; + nano::uint256_union ciphertext; ciphertext.encrypt (prv, password_l, pub.owords[0].number ()); - entry_put_raw (transaction_a, pub, rai::wallet_value (ciphertext, 0)); + entry_put_raw (transaction_a, pub, nano::wallet_value (ciphertext, 0)); return pub; } -void rai::wallet_store::insert_watch (rai::transaction const & transaction_a, rai::public_key const & pub) +void nano::wallet_store::insert_watch (nano::transaction const & transaction_a, nano::public_key const & pub) { - entry_put_raw (transaction_a, pub, rai::wallet_value (rai::uint256_union (0), 0)); + entry_put_raw (transaction_a, pub, nano::wallet_value (nano::uint256_union (0), 0)); } -void rai::wallet_store::erase (rai::transaction const & transaction_a, rai::public_key const & pub) +void nano::wallet_store::erase (nano::transaction const & transaction_a, nano::public_key const & pub) { - auto status (mdb_del (tx (transaction_a), handle, rai::mdb_val (pub), nullptr)); + auto status (mdb_del (tx (transaction_a), handle, nano::mdb_val (pub), nullptr)); assert (status == 0); } -rai::wallet_value rai::wallet_store::entry_get_raw (rai::transaction const & transaction_a, rai::public_key const & pub_a) +nano::wallet_value nano::wallet_store::entry_get_raw (nano::transaction const & transaction_a, nano::public_key const & pub_a) { - rai::wallet_value result; - rai::mdb_val value; - auto status (mdb_get (tx (transaction_a), handle, rai::mdb_val (pub_a), value)); + nano::wallet_value result; + nano::mdb_val value; + auto status (mdb_get (tx (transaction_a), handle, nano::mdb_val (pub_a), value)); if (status == 0) { - result = rai::wallet_value (value); + result = nano::wallet_value (value); } else { @@ -429,57 +429,57 @@ rai::wallet_value rai::wallet_store::entry_get_raw (rai::transaction const & tra return result; } -void rai::wallet_store::entry_put_raw (rai::transaction const & transaction_a, rai::public_key const & pub_a, rai::wallet_value const & entry_a) +void nano::wallet_store::entry_put_raw (nano::transaction const & transaction_a, nano::public_key const & pub_a, nano::wallet_value const & entry_a) { - auto status (mdb_put (tx (transaction_a), handle, rai::mdb_val (pub_a), entry_a.val (), 0)); + auto status (mdb_put (tx (transaction_a), handle, nano::mdb_val (pub_a), entry_a.val (), 0)); assert (status == 0); } -rai::key_type rai::wallet_store::key_type (rai::wallet_value const & value_a) +nano::key_type nano::wallet_store::key_type (nano::wallet_value const & value_a) { auto number (value_a.key.number ()); - rai::key_type result; + nano::key_type result; auto text (number.convert_to ()); if (number > std::numeric_limits::max ()) { - result = rai::key_type::adhoc; + result = nano::key_type::adhoc; } else { if ((number >> 32).convert_to () == 1) { - result = rai::key_type::deterministic; + result = nano::key_type::deterministic; } else { - result = rai::key_type::unknown; + result = nano::key_type::unknown; } } return result; } -bool rai::wallet_store::fetch (rai::transaction const & transaction_a, rai::public_key const & pub, rai::raw_key & prv) +bool nano::wallet_store::fetch (nano::transaction const & transaction_a, nano::public_key const & pub, nano::raw_key & prv) { auto result (false); if (valid_password (transaction_a)) { - rai::wallet_value value (entry_get_raw (transaction_a, pub)); + nano::wallet_value value (entry_get_raw (transaction_a, pub)); if (!value.key.is_zero ()) { switch (key_type (value)) { - case rai::key_type::deterministic: + case nano::key_type::deterministic: { - rai::raw_key seed_l; + nano::raw_key seed_l; seed (seed_l, transaction_a); uint32_t index (static_cast (value.key.number () & static_cast (-1))); deterministic_key (prv, transaction_a, index); break; } - case rai::key_type::adhoc: + case nano::key_type::adhoc: { // Ad-hoc keys - rai::raw_key password_l; + nano::raw_key password_l; wallet_key (password_l, transaction_a); prv.decrypt (value.key, password_l, pub.owords[0].number ()); break; @@ -502,7 +502,7 @@ bool rai::wallet_store::fetch (rai::transaction const & transaction_a, rai::publ } if (!result) { - rai::public_key compare (rai::pub_key (prv.data)); + nano::public_key compare (nano::pub_key (prv.data)); if (!(pub == compare)) { result = true; @@ -511,15 +511,15 @@ bool rai::wallet_store::fetch (rai::transaction const & transaction_a, rai::publ return result; } -bool rai::wallet_store::exists (rai::transaction const & transaction_a, rai::public_key const & pub) +bool nano::wallet_store::exists (nano::transaction const & transaction_a, nano::public_key const & pub) { return !pub.is_zero () && find (transaction_a, pub) != end (); } -void rai::wallet_store::serialize_json (rai::transaction const & transaction_a, std::string & string_a) +void nano::wallet_store::serialize_json (nano::transaction const & transaction_a, std::string & string_a) { boost::property_tree::ptree tree; - for (rai::store_iterator i (std::make_unique> (transaction_a, handle)), n (nullptr); i != n; ++i) + for (nano::store_iterator i (std::make_unique> (transaction_a, handle)), n (nullptr); i != n; ++i) { tree.put (i->first.to_string (), i->second.key.to_string ()); } @@ -528,7 +528,7 @@ void rai::wallet_store::serialize_json (rai::transaction const & transaction_a, string_a = ostream.str (); } -void rai::wallet_store::write_backup (rai::transaction const & transaction_a, boost::filesystem::path const & path_a) +void nano::wallet_store::write_backup (nano::transaction const & transaction_a, boost::filesystem::path const & path_a) { std::ofstream backup_file; backup_file.open (path_a.string ()); @@ -536,7 +536,7 @@ void rai::wallet_store::write_backup (rai::transaction const & transaction_a, bo { // Set permissions to 600 boost::system::error_code ec; - rai::set_secure_perm_file (path_a, ec); + nano::set_secure_perm_file (path_a, ec); std::string json; serialize_json (transaction_a, json); @@ -544,14 +544,14 @@ void rai::wallet_store::write_backup (rai::transaction const & transaction_a, bo } } -bool rai::wallet_store::move (rai::transaction const & transaction_a, rai::wallet_store & other_a, std::vector const & keys) +bool nano::wallet_store::move (nano::transaction const & transaction_a, nano::wallet_store & other_a, std::vector const & keys) { assert (valid_password (transaction_a)); assert (other_a.valid_password (transaction_a)); auto result (false); for (auto i (keys.begin ()), n (keys.end ()); i != n; ++i) { - rai::raw_key prv; + nano::raw_key prv; auto error (other_a.fetch (transaction_a, *i, prv)); result = result | error; if (!result) @@ -563,15 +563,15 @@ bool rai::wallet_store::move (rai::transaction const & transaction_a, rai::walle return result; } -bool rai::wallet_store::import (rai::transaction const & transaction_a, rai::wallet_store & other_a) +bool nano::wallet_store::import (nano::transaction const & transaction_a, nano::wallet_store & other_a) { assert (valid_password (transaction_a)); assert (other_a.valid_password (transaction_a)); auto result (false); for (auto i (other_a.begin (transaction_a)), n (end ()); i != n; ++i) { - rai::raw_key prv; - auto error (other_a.fetch (transaction_a, rai::uint256_union (i->first), prv)); + nano::raw_key prv; + auto error (other_a.fetch (transaction_a, nano::uint256_union (i->first), prv)); result = result | error; if (!result) { @@ -581,15 +581,15 @@ bool rai::wallet_store::import (rai::transaction const & transaction_a, rai::wal } else { - insert_watch (transaction_a, rai::uint256_union (i->first)); + insert_watch (transaction_a, nano::uint256_union (i->first)); } - other_a.erase (transaction_a, rai::uint256_union (i->first)); + other_a.erase (transaction_a, nano::uint256_union (i->first)); } } return result; } -bool rai::wallet_store::work_get (rai::transaction const & transaction_a, rai::public_key const & pub_a, uint64_t & work_a) +bool nano::wallet_store::work_get (nano::transaction const & transaction_a, nano::public_key const & pub_a, uint64_t & work_a) { auto result (false); auto entry (entry_get_raw (transaction_a, pub_a)); @@ -604,7 +604,7 @@ bool rai::wallet_store::work_get (rai::transaction const & transaction_a, rai::p return result; } -void rai::wallet_store::work_put (rai::transaction const & transaction_a, rai::public_key const & pub_a, uint64_t work_a) +void nano::wallet_store::work_put (nano::transaction const & transaction_a, nano::public_key const & pub_a, uint64_t work_a) { auto entry (entry_get_raw (transaction_a, pub_a)); assert (!entry.key.is_zero ()); @@ -612,41 +612,41 @@ void rai::wallet_store::work_put (rai::transaction const & transaction_a, rai::p entry_put_raw (transaction_a, pub_a, entry); } -unsigned rai::wallet_store::version (rai::transaction const & transaction_a) +unsigned nano::wallet_store::version (nano::transaction const & transaction_a) { - rai::wallet_value value (entry_get_raw (transaction_a, rai::wallet_store::version_special)); + nano::wallet_value value (entry_get_raw (transaction_a, nano::wallet_store::version_special)); auto entry (value.key); auto result (static_cast (entry.bytes[31])); return result; } -void rai::wallet_store::version_put (rai::transaction const & transaction_a, unsigned version_a) +void nano::wallet_store::version_put (nano::transaction const & transaction_a, unsigned version_a) { - rai::uint256_union entry (version_a); - entry_put_raw (transaction_a, rai::wallet_store::version_special, rai::wallet_value (entry, 0)); + nano::uint256_union entry (version_a); + entry_put_raw (transaction_a, nano::wallet_store::version_special, nano::wallet_value (entry, 0)); } -void rai::wallet_store::upgrade_v1_v2 (rai::transaction const & transaction_a) +void nano::wallet_store::upgrade_v1_v2 (nano::transaction const & transaction_a) { assert (version (transaction_a) == 1); - rai::raw_key zero_password; - rai::wallet_value value (entry_get_raw (transaction_a, rai::wallet_store::wallet_key_special)); - rai::raw_key kdf; + nano::raw_key zero_password; + nano::wallet_value value (entry_get_raw (transaction_a, nano::wallet_store::wallet_key_special)); + nano::raw_key kdf; kdf.data.clear (); zero_password.decrypt (value.key, kdf, salt (transaction_a).owords[0]); derive_key (kdf, transaction_a, ""); - rai::raw_key empty_password; + nano::raw_key empty_password; empty_password.decrypt (value.key, kdf, salt (transaction_a).owords[0]); for (auto i (begin (transaction_a)), n (end ()); i != n; ++i) { - rai::public_key key (i->first); - rai::raw_key prv; + nano::public_key key (i->first); + nano::raw_key prv; if (fetch (transaction_a, key, prv)) { // Key failed to decrypt despite valid password - rai::wallet_value data (entry_get_raw (transaction_a, key)); + nano::wallet_value data (entry_get_raw (transaction_a, key)); prv.decrypt (data.key, zero_password, salt (transaction_a).owords[0]); - rai::public_key compare (rai::pub_key (prv.data)); + nano::public_key compare (nano::pub_key (prv.data)); if (compare == key) { // If we successfully decrypted it, rewrite the key back with the correct wallet key @@ -655,9 +655,9 @@ void rai::wallet_store::upgrade_v1_v2 (rai::transaction const & transaction_a) else { // Also try the empty password - rai::wallet_value data (entry_get_raw (transaction_a, key)); + nano::wallet_value data (entry_get_raw (transaction_a, key)); prv.decrypt (data.key, empty_password, salt (transaction_a).owords[0]); - rai::public_key compare (rai::pub_key (prv.data)); + nano::public_key compare (nano::pub_key (prv.data)); if (compare == key) { // If we successfully decrypted it, rewrite the key back with the correct wallet key @@ -669,51 +669,51 @@ void rai::wallet_store::upgrade_v1_v2 (rai::transaction const & transaction_a) version_put (transaction_a, 2); } -void rai::wallet_store::upgrade_v2_v3 (rai::transaction const & transaction_a) +void nano::wallet_store::upgrade_v2_v3 (nano::transaction const & transaction_a) { assert (version (transaction_a) == 2); - rai::raw_key seed; + nano::raw_key seed; random_pool.GenerateBlock (seed.data.bytes.data (), seed.data.bytes.size ()); seed_set (transaction_a, seed); - entry_put_raw (transaction_a, rai::wallet_store::deterministic_index_special, rai::wallet_value (rai::uint256_union (0), 0)); + entry_put_raw (transaction_a, nano::wallet_store::deterministic_index_special, nano::wallet_value (nano::uint256_union (0), 0)); version_put (transaction_a, 3); } -void rai::wallet_store::upgrade_v3_v4 (rai::transaction const & transaction_a) +void nano::wallet_store::upgrade_v3_v4 (nano::transaction const & transaction_a) { assert (version (transaction_a) == 3); version_put (transaction_a, 4); assert (valid_password (transaction_a)); - rai::raw_key seed; - rai::wallet_value value (entry_get_raw (transaction_a, rai::wallet_store::seed_special)); - rai::raw_key password_l; + nano::raw_key seed; + nano::wallet_value value (entry_get_raw (transaction_a, nano::wallet_store::seed_special)); + nano::raw_key password_l; wallet_key (password_l, transaction_a); seed.decrypt (value.key, password_l, salt (transaction_a).owords[0]); - rai::uint256_union ciphertext; + nano::uint256_union ciphertext; ciphertext.encrypt (seed, password_l, salt (transaction_a).owords[seed_iv_index]); - entry_put_raw (transaction_a, rai::wallet_store::seed_special, rai::wallet_value (ciphertext, 0)); + entry_put_raw (transaction_a, nano::wallet_store::seed_special, nano::wallet_value (ciphertext, 0)); for (auto i (begin (transaction_a)), n (end ()); i != n; ++i) { - rai::wallet_value value (i->second); + nano::wallet_value value (i->second); if (!value.key.is_zero ()) { switch (key_type (i->second)) { - case rai::key_type::adhoc: + case nano::key_type::adhoc: { - rai::raw_key key; - if (fetch (transaction_a, rai::public_key (i->first), key)) + nano::raw_key key; + if (fetch (transaction_a, nano::public_key (i->first), key)) { // Key failed to decrypt despite valid password key.decrypt (value.key, password_l, salt (transaction_a).owords[0]); - rai::uint256_union new_key_ciphertext; - new_key_ciphertext.encrypt (key, password_l, (rai::uint256_union (i->first)).owords[0].number ()); - rai::wallet_value new_value (new_key_ciphertext, value.work); - erase (transaction_a, rai::public_key (i->first)); - entry_put_raw (transaction_a, rai::public_key (i->first), new_value); + nano::uint256_union new_key_ciphertext; + new_key_ciphertext.encrypt (key, password_l, (nano::uint256_union (i->first)).owords[0].number ()); + nano::wallet_value new_value (new_key_ciphertext, value.work); + erase (transaction_a, nano::public_key (i->first)); + entry_put_raw (transaction_a, nano::public_key (i->first), new_value); } } - case rai::key_type::deterministic: + case nano::key_type::deterministic: break; default: assert (false); @@ -722,32 +722,32 @@ void rai::wallet_store::upgrade_v3_v4 (rai::transaction const & transaction_a) } } -void rai::kdf::phs (rai::raw_key & result_a, std::string const & password_a, rai::uint256_union const & salt_a) +void nano::kdf::phs (nano::raw_key & result_a, std::string const & password_a, nano::uint256_union const & salt_a) { std::lock_guard lock (mutex); - auto success (argon2_hash (1, rai::wallet_store::kdf_work, 1, password_a.data (), password_a.size (), salt_a.bytes.data (), salt_a.bytes.size (), result_a.data.bytes.data (), result_a.data.bytes.size (), NULL, 0, Argon2_d, 0x10)); + auto success (argon2_hash (1, nano::wallet_store::kdf_work, 1, password_a.data (), password_a.size (), salt_a.bytes.data (), salt_a.bytes.size (), result_a.data.bytes.data (), result_a.data.bytes.size (), NULL, 0, Argon2_d, 0x10)); assert (success == 0); (void)success; } -rai::wallet::wallet (bool & init_a, rai::transaction & transaction_a, rai::wallets & wallets_a, std::string const & wallet_a) : +nano::wallet::wallet (bool & init_a, nano::transaction & transaction_a, nano::wallets & wallets_a, std::string const & wallet_a) : lock_observer ([](bool, bool) {}), store (init_a, wallets_a.kdf, transaction_a, wallets_a.node.config.random_representative (), wallets_a.node.config.password_fanout, wallet_a), wallets (wallets_a) { } -rai::wallet::wallet (bool & init_a, rai::transaction & transaction_a, rai::wallets & wallets_a, std::string const & wallet_a, std::string const & json) : +nano::wallet::wallet (bool & init_a, nano::transaction & transaction_a, nano::wallets & wallets_a, std::string const & wallet_a, std::string const & json) : lock_observer ([](bool, bool) {}), store (init_a, wallets_a.kdf, transaction_a, wallets_a.node.config.random_representative (), wallets_a.node.config.password_fanout, wallet_a, json), wallets (wallets_a) { } -void rai::wallet::enter_initial_password () +void nano::wallet::enter_initial_password () { std::lock_guard lock (store.mutex); - rai::raw_key password_l; + nano::raw_key password_l; store.password.value (password_l); if (password_l.data.is_zero ()) { @@ -764,7 +764,7 @@ void rai::wallet::enter_initial_password () } } -bool rai::wallet::enter_password (rai::transaction const & transaction_a, std::string const & password_a) +bool nano::wallet::enter_password (nano::transaction const & transaction_a, std::string const & password_a) { auto result (store.attempt_password (transaction_a, password_a)); if (!result) @@ -778,9 +778,9 @@ bool rai::wallet::enter_password (rai::transaction const & transaction_a, std::s return result; } -rai::public_key rai::wallet::deterministic_insert (rai::transaction const & transaction_a, bool generate_work_a) +nano::public_key nano::wallet::deterministic_insert (nano::transaction const & transaction_a, bool generate_work_a) { - rai::public_key key (0); + nano::public_key key (0); if (store.valid_password (transaction_a)) { key = store.deterministic_insert (transaction_a); @@ -792,16 +792,16 @@ rai::public_key rai::wallet::deterministic_insert (rai::transaction const & tran return key; } -rai::public_key rai::wallet::deterministic_insert (bool generate_work_a) +nano::public_key nano::wallet::deterministic_insert (bool generate_work_a) { auto transaction (wallets.tx_begin_write ()); auto result (deterministic_insert (transaction, generate_work_a)); return result; } -rai::public_key rai::wallet::insert_adhoc (rai::transaction const & transaction_a, rai::raw_key const & key_a, bool generate_work_a) +nano::public_key nano::wallet::insert_adhoc (nano::transaction const & transaction_a, nano::raw_key const & key_a, bool generate_work_a) { - rai::public_key key (0); + nano::public_key key (0); if (store.valid_password (transaction_a)) { key = store.insert_adhoc (transaction_a, key_a); @@ -813,33 +813,33 @@ rai::public_key rai::wallet::insert_adhoc (rai::transaction const & transaction_ return key; } -rai::public_key rai::wallet::insert_adhoc (rai::raw_key const & account_a, bool generate_work_a) +nano::public_key nano::wallet::insert_adhoc (nano::raw_key const & account_a, bool generate_work_a) { auto transaction (wallets.tx_begin_write ()); auto result (insert_adhoc (transaction, account_a, generate_work_a)); return result; } -void rai::wallet::insert_watch (rai::transaction const & transaction_a, rai::public_key const & pub_a) +void nano::wallet::insert_watch (nano::transaction const & transaction_a, nano::public_key const & pub_a) { store.insert_watch (transaction_a, pub_a); } -bool rai::wallet::exists (rai::public_key const & account_a) +bool nano::wallet::exists (nano::public_key const & account_a) { auto transaction (wallets.tx_begin_read ()); return store.exists (transaction, account_a); } -bool rai::wallet::import (std::string const & json_a, std::string const & password_a) +bool nano::wallet::import (std::string const & json_a, std::string const & password_a) { auto error (false); - std::unique_ptr temp; + std::unique_ptr temp; { auto transaction (wallets.tx_begin_write ()); - rai::uint256_union id; + nano::uint256_union id; random_pool.GenerateBlock (id.bytes.data (), id.bytes.size ()); - temp.reset (new rai::wallet_store (error, wallets.node.wallets.kdf, transaction, 0, 1, id.to_string (), json_a)); + temp.reset (new nano::wallet_store (error, wallets.node.wallets.kdf, transaction, 0, 1, id.to_string (), json_a)); } if (!error) { @@ -855,49 +855,49 @@ bool rai::wallet::import (std::string const & json_a, std::string const & passwo return error; } -void rai::wallet::serialize (std::string & json_a) +void nano::wallet::serialize (std::string & json_a) { auto transaction (wallets.tx_begin_read ()); store.serialize_json (transaction, json_a); } -void rai::wallet_store::destroy (rai::transaction const & transaction_a) +void nano::wallet_store::destroy (nano::transaction const & transaction_a) { auto status (mdb_drop (tx (transaction_a), handle, 1)); assert (status == 0); handle = 0; } -std::shared_ptr rai::wallet::receive_action (rai::block const & send_a, rai::account const & representative_a, rai::uint128_union const & amount_a, bool generate_work_a) +std::shared_ptr nano::wallet::receive_action (nano::block const & send_a, nano::account const & representative_a, nano::uint128_union const & amount_a, bool generate_work_a) { - rai::account account; + nano::account account; auto hash (send_a.hash ()); - std::shared_ptr block; + std::shared_ptr block; if (wallets.node.config.receive_minimum.number () <= amount_a.number ()) { auto transaction (wallets.node.ledger.store.tx_begin_read ()); - rai::pending_info pending_info; + nano::pending_info pending_info; if (wallets.node.store.block_exists (transaction, hash)) { account = wallets.node.ledger.block_destination (transaction, send_a); - if (!wallets.node.ledger.store.pending_get (transaction, rai::pending_key (account, hash), pending_info)) + if (!wallets.node.ledger.store.pending_get (transaction, nano::pending_key (account, hash), pending_info)) { - rai::raw_key prv; + nano::raw_key prv; if (!store.fetch (transaction, account, prv)) { uint64_t cached_work (0); store.work_get (transaction, account, cached_work); - rai::account_info info; + nano::account_info info; auto new_account (wallets.node.ledger.store.account_get (transaction, account, info)); if (!new_account) { - std::shared_ptr rep_block = wallets.node.ledger.store.block_get (transaction, info.rep_block); + std::shared_ptr rep_block = wallets.node.ledger.store.block_get (transaction, info.rep_block); assert (rep_block != nullptr); - block.reset (new rai::state_block (account, info.head, rep_block->representative (), info.balance.number () + pending_info.amount.number (), hash, prv, account, cached_work)); + block.reset (new nano::state_block (account, info.head, rep_block->representative (), info.balance.number () + pending_info.amount.number (), hash, prv, account, cached_work)); } else { - block.reset (new rai::state_block (account, 0, representative_a, pending_info.amount, hash, prv, account, cached_work)); + block.reset (new nano::state_block (account, 0, representative_a, pending_info.amount, hash, prv, account, cached_work)); } } else @@ -922,7 +922,7 @@ std::shared_ptr rai::wallet::receive_action (rai::block const & send } if (block != nullptr) { - if (rai::work_validate (*block)) + if (nano::work_validate (*block)) { wallets.node.work_generate_blocking (*block); } @@ -936,9 +936,9 @@ std::shared_ptr rai::wallet::receive_action (rai::block const & send return block; } -std::shared_ptr rai::wallet::change_action (rai::account const & source_a, rai::account const & representative_a, bool generate_work_a) +std::shared_ptr nano::wallet::change_action (nano::account const & source_a, nano::account const & representative_a, bool generate_work_a) { - std::shared_ptr block; + std::shared_ptr block; { auto transaction (wallets.tx_begin_read ()); if (store.valid_password (transaction)) @@ -946,21 +946,21 @@ std::shared_ptr rai::wallet::change_action (rai::account const & sou auto existing (store.find (transaction, source_a)); if (existing != store.end () && !wallets.node.ledger.latest (transaction, source_a).is_zero ()) { - rai::account_info info; + nano::account_info info; auto error1 (wallets.node.ledger.store.account_get (transaction, source_a, info)); assert (!error1); - rai::raw_key prv; + nano::raw_key prv; auto error2 (store.fetch (transaction, source_a, prv)); assert (!error2); uint64_t cached_work (0); store.work_get (transaction, source_a, cached_work); - block.reset (new rai::state_block (source_a, info.head, representative_a, info.balance, 0, prv, source_a, cached_work)); + block.reset (new nano::state_block (source_a, info.head, representative_a, info.balance, 0, prv, source_a, cached_work)); } } } if (block != nullptr) { - if (rai::work_validate (*block)) + if (nano::work_validate (*block)) { wallets.node.work_generate_blocking (*block); } @@ -974,13 +974,13 @@ std::shared_ptr rai::wallet::change_action (rai::account const & sou return block; } -std::shared_ptr rai::wallet::send_action (rai::account const & source_a, rai::account const & account_a, rai::uint128_t const & amount_a, bool generate_work_a, boost::optional id_a) +std::shared_ptr nano::wallet::send_action (nano::account const & source_a, nano::account const & account_a, nano::uint128_t const & amount_a, bool generate_work_a, boost::optional id_a) { - std::shared_ptr block; - boost::optional id_mdb_val; + std::shared_ptr block; + boost::optional id_mdb_val; if (id_a) { - id_mdb_val = rai::mdb_val (id_a->size (), const_cast (id_a->data ())); + id_mdb_val = nano::mdb_val (id_a->size (), const_cast (id_a->data ())); } bool error = false; bool cached_block = false; @@ -988,11 +988,11 @@ std::shared_ptr rai::wallet::send_action (rai::account const & sourc auto transaction (wallets.tx_begin ((bool)id_mdb_val)); if (id_mdb_val) { - rai::mdb_val result; + nano::mdb_val result; auto status (mdb_get (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, *id_mdb_val, result)); if (status == 0) { - rai::uint256_union hash (result); + nano::uint256_union hash (result); block = wallets.node.store.block_get (transaction, hash); if (block != nullptr) { @@ -1015,20 +1015,20 @@ std::shared_ptr rai::wallet::send_action (rai::account const & sourc auto balance (wallets.node.ledger.account_balance (transaction, source_a)); if (!balance.is_zero () && balance >= amount_a) { - rai::account_info info; + nano::account_info info; auto error1 (wallets.node.ledger.store.account_get (transaction, source_a, info)); assert (!error1); - rai::raw_key prv; + nano::raw_key prv; auto error2 (store.fetch (transaction, source_a, prv)); assert (!error2); - std::shared_ptr rep_block = wallets.node.ledger.store.block_get (transaction, info.rep_block); + std::shared_ptr rep_block = wallets.node.ledger.store.block_get (transaction, info.rep_block); assert (rep_block != nullptr); uint64_t cached_work (0); store.work_get (transaction, source_a, cached_work); - block.reset (new rai::state_block (source_a, info.head, rep_block->representative (), balance - amount_a, account_a, prv, source_a, cached_work)); + block.reset (new nano::state_block (source_a, info.head, rep_block->representative (), balance - amount_a, account_a, prv, source_a, cached_work)); if (id_mdb_val && block != nullptr) { - auto status (mdb_put (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, *id_mdb_val, rai::mdb_val (block->hash ()), 0)); + auto status (mdb_put (wallets.env.tx (transaction), wallets.node.wallets.send_action_ids, *id_mdb_val, nano::mdb_val (block->hash ()), 0)); if (status != 0) { block = nullptr; @@ -1042,7 +1042,7 @@ std::shared_ptr rai::wallet::send_action (rai::account const & sourc } if (!error && block != nullptr && !cached_block) { - if (rai::work_validate (*block)) + if (nano::work_validate (*block)) { wallets.node.work_generate_blocking (*block); } @@ -1056,65 +1056,65 @@ std::shared_ptr rai::wallet::send_action (rai::account const & sourc return block; } -bool rai::wallet::change_sync (rai::account const & source_a, rai::account const & representative_a) +bool nano::wallet::change_sync (nano::account const & source_a, nano::account const & representative_a) { std::promise result; - change_async (source_a, representative_a, [&result](std::shared_ptr block_a) { + change_async (source_a, representative_a, [&result](std::shared_ptr block_a) { result.set_value (block_a == nullptr); }, true); return result.get_future ().get (); } -void rai::wallet::change_async (rai::account const & source_a, rai::account const & representative_a, std::function)> const & action_a, bool generate_work_a) +void nano::wallet::change_async (nano::account const & source_a, nano::account const & representative_a, std::function)> const & action_a, bool generate_work_a) { - wallets.node.wallets.queue_wallet_action (rai::wallets::high_priority, shared_from_this (), [source_a, representative_a, action_a, generate_work_a](rai::wallet & wallet_a) { + wallets.node.wallets.queue_wallet_action (nano::wallets::high_priority, shared_from_this (), [source_a, representative_a, action_a, generate_work_a](nano::wallet & wallet_a) { auto block (wallet_a.change_action (source_a, representative_a, generate_work_a)); action_a (block); }); } -bool rai::wallet::receive_sync (std::shared_ptr block_a, rai::account const & representative_a, rai::uint128_t const & amount_a) +bool nano::wallet::receive_sync (std::shared_ptr block_a, nano::account const & representative_a, nano::uint128_t const & amount_a) { std::promise result; - receive_async (block_a, representative_a, amount_a, [&result](std::shared_ptr block_a) { + receive_async (block_a, representative_a, amount_a, [&result](std::shared_ptr block_a) { result.set_value (block_a == nullptr); }, true); return result.get_future ().get (); } -void rai::wallet::receive_async (std::shared_ptr block_a, rai::account const & representative_a, rai::uint128_t const & amount_a, std::function)> const & action_a, bool generate_work_a) +void nano::wallet::receive_async (std::shared_ptr block_a, nano::account const & representative_a, nano::uint128_t const & amount_a, std::function)> const & action_a, bool generate_work_a) { - //assert (dynamic_cast (block_a.get ()) != nullptr); - wallets.node.wallets.queue_wallet_action (amount_a, shared_from_this (), [block_a, representative_a, amount_a, action_a, generate_work_a](rai::wallet & wallet_a) { - auto block (wallet_a.receive_action (*static_cast (block_a.get ()), representative_a, amount_a, generate_work_a)); + //assert (dynamic_cast (block_a.get ()) != nullptr); + wallets.node.wallets.queue_wallet_action (amount_a, shared_from_this (), [block_a, representative_a, amount_a, action_a, generate_work_a](nano::wallet & wallet_a) { + auto block (wallet_a.receive_action (*static_cast (block_a.get ()), representative_a, amount_a, generate_work_a)); action_a (block); }); } -rai::block_hash rai::wallet::send_sync (rai::account const & source_a, rai::account const & account_a, rai::uint128_t const & amount_a) +nano::block_hash nano::wallet::send_sync (nano::account const & source_a, nano::account const & account_a, nano::uint128_t const & amount_a) { - std::promise result; - send_async (source_a, account_a, amount_a, [&result](std::shared_ptr block_a) { + std::promise result; + send_async (source_a, account_a, amount_a, [&result](std::shared_ptr block_a) { result.set_value (block_a->hash ()); }, true); return result.get_future ().get (); } -void rai::wallet::send_async (rai::account const & source_a, rai::account const & account_a, rai::uint128_t const & amount_a, std::function)> const & action_a, bool generate_work_a, boost::optional id_a) +void nano::wallet::send_async (nano::account const & source_a, nano::account const & account_a, nano::uint128_t const & amount_a, std::function)> const & action_a, bool generate_work_a, boost::optional id_a) { - wallets.node.wallets.queue_wallet_action (rai::wallets::high_priority, shared_from_this (), [source_a, account_a, amount_a, action_a, generate_work_a, id_a](rai::wallet & wallet_a) { + wallets.node.wallets.queue_wallet_action (nano::wallets::high_priority, shared_from_this (), [source_a, account_a, amount_a, action_a, generate_work_a, id_a](nano::wallet & wallet_a) { auto block (wallet_a.send_action (source_a, account_a, amount_a, generate_work_a, id_a)); action_a (block); }); } // Update work for account if latest root is root_a -void rai::wallet::work_update (rai::transaction const & transaction_a, rai::account const & account_a, rai::block_hash const & root_a, uint64_t work_a) +void nano::wallet::work_update (nano::transaction const & transaction_a, nano::account const & account_a, nano::block_hash const & root_a, uint64_t work_a) { - assert (!rai::work_validate (root_a, work_a)); + assert (!nano::work_validate (root_a, work_a)); assert (store.exists (transaction_a, account_a)); auto latest (wallets.node.ledger.latest_root (transaction_a, account_a)); if (latest == root_a) @@ -1127,14 +1127,14 @@ void rai::wallet::work_update (rai::transaction const & transaction_a, rai::acco } } -void rai::wallet::work_ensure (rai::account const & account_a, rai::block_hash const & hash_a) +void nano::wallet::work_ensure (nano::account const & account_a, nano::block_hash const & hash_a) { - wallets.node.wallets.queue_wallet_action (rai::wallets::generate_priority, shared_from_this (), [account_a, hash_a](rai::wallet & wallet_a) { + wallets.node.wallets.queue_wallet_action (nano::wallets::generate_priority, shared_from_this (), [account_a, hash_a](nano::wallet & wallet_a) { wallet_a.work_cache_blocking (account_a, hash_a); }); } -bool rai::wallet::search_pending () +bool nano::wallet::search_pending () { auto transaction (wallets.tx_begin_read ()); auto result (!store.valid_password (transaction)); @@ -1144,15 +1144,15 @@ bool rai::wallet::search_pending () for (auto i (store.begin (transaction)), n (store.end ()); i != n; ++i) { auto transaction (wallets.node.store.tx_begin_read ()); - rai::account account (i->first); + nano::account account (i->first); // Don't search pending for watch-only accounts - if (!rai::wallet_value (i->second).key.is_zero ()) + if (!nano::wallet_value (i->second).key.is_zero ()) { - for (auto j (wallets.node.store.pending_begin (transaction, rai::pending_key (account, 0))); rai::pending_key (j->first).account == account; ++j) + for (auto j (wallets.node.store.pending_begin (transaction, nano::pending_key (account, 0))); nano::pending_key (j->first).account == account; ++j) { - rai::pending_key key (j->first); + nano::pending_key key (j->first); auto hash (key.hash); - rai::pending_info pending (j->second); + nano::pending_info pending (j->second); auto amount (pending.amount.number ()); if (wallets.node.config.receive_minimum.number () <= amount) { @@ -1171,25 +1171,25 @@ bool rai::wallet::search_pending () return result; } -void rai::wallet::init_free_accounts (rai::transaction const & transaction_a) +void nano::wallet::init_free_accounts (nano::transaction const & transaction_a) { free_accounts.clear (); for (auto i (store.begin (transaction_a)), n (store.end ()); i != n; ++i) { - free_accounts.insert (rai::uint256_union (i->first)); + free_accounts.insert (nano::uint256_union (i->first)); } } -rai::public_key rai::wallet::change_seed (rai::transaction const & transaction_a, rai::raw_key const & prv_a) +nano::public_key nano::wallet::change_seed (nano::transaction const & transaction_a, nano::raw_key const & prv_a) { store.seed_set (transaction_a, prv_a); auto account = deterministic_insert (transaction_a); uint32_t count (0); for (uint32_t i (1), n (64); i < n; ++i) { - rai::raw_key prv; + nano::raw_key prv; store.deterministic_key (prv, transaction_a, i); - rai::keypair pair (prv.data.to_string ()); + nano::keypair pair (prv.data.to_string ()); // Check if account received at least 1 block auto latest (wallets.node.ledger.latest (transaction_a, pair.pub)); if (!latest.is_zero ()) @@ -1202,7 +1202,7 @@ rai::public_key rai::wallet::change_seed (rai::transaction const & transaction_a else { // Check if there are pending blocks for account - for (auto ii (wallets.node.store.pending_begin (transaction_a, rai::pending_key (pair.pub, 0))); rai::pending_key (ii->first).account == pair.pub; ++ii) + for (auto ii (wallets.node.store.pending_begin (transaction_a, nano::pending_key (pair.pub, 0))); nano::pending_key (ii->first).account == pair.pub; ++ii) { count = i; n = i + 64 + (i / 64); @@ -1219,12 +1219,12 @@ rai::public_key rai::wallet::change_seed (rai::transaction const & transaction_a return account; } -bool rai::wallet::live () +bool nano::wallet::live () { return store.handle != 0; } -void rai::wallet::work_cache_blocking (rai::account const & account_a, rai::block_hash const & root_a) +void nano::wallet::work_cache_blocking (nano::account const & account_a, nano::block_hash const & root_a) { auto begin (std::chrono::steady_clock::now ()); auto work (wallets.node.work_generate_blocking (root_a)); @@ -1239,13 +1239,13 @@ void rai::wallet::work_cache_blocking (rai::account const & account_a, rai::bloc } } -rai::wallets::wallets (bool & error_a, rai::node & node_a) : +nano::wallets::wallets (bool & error_a, nano::node & node_a) : observer ([](bool) {}), node (node_a), -env (boost::polymorphic_downcast (node_a.store_impl.get ())->env), +env (boost::polymorphic_downcast (node_a.store_impl.get ())->env), stopped (false), thread ([this]() { - rai::thread_role::set (rai::thread_role::name::wallet_actions); + nano::thread_role::set (nano::thread_role::name::wallet_actions); do_wallet_actions (); }) { @@ -1255,18 +1255,18 @@ thread ([this]() { auto status (mdb_dbi_open (env.tx (transaction), nullptr, MDB_CREATE, &handle)); status |= mdb_dbi_open (env.tx (transaction), "send_action_ids", MDB_CREATE, &send_action_ids); assert (status == 0); - std::string beginning (rai::uint256_union (0).to_string ()); - std::string end ((rai::uint256_union (rai::uint256_t (0) - rai::uint256_t (1))).to_string ()); - rai::store_iterator, rai::mdb_val::no_value> i (std::make_unique, rai::mdb_val::no_value>> (transaction, handle, rai::mdb_val (beginning.size (), const_cast (beginning.c_str ())))); - rai::store_iterator, rai::mdb_val::no_value> n (std::make_unique, rai::mdb_val::no_value>> (transaction, handle, rai::mdb_val (end.size (), const_cast (end.c_str ())))); + std::string beginning (nano::uint256_union (0).to_string ()); + std::string end ((nano::uint256_union (nano::uint256_t (0) - nano::uint256_t (1))).to_string ()); + nano::store_iterator, nano::mdb_val::no_value> i (std::make_unique, nano::mdb_val::no_value>> (transaction, handle, nano::mdb_val (beginning.size (), const_cast (beginning.c_str ())))); + nano::store_iterator, nano::mdb_val::no_value> n (std::make_unique, nano::mdb_val::no_value>> (transaction, handle, nano::mdb_val (end.size (), const_cast (end.c_str ())))); for (; i != n; ++i) { - rai::uint256_union id; + nano::uint256_union id; std::string text (i->first.data (), i->first.size ()); auto error (id.decode_hex (text)); assert (!error); assert (items.find (id) == items.end ()); - auto wallet (std::make_shared (error, transaction, *this, text)); + auto wallet (std::make_shared (error, transaction, *this, text)); if (!error) { items[id] = wallet; @@ -1283,14 +1283,14 @@ thread ([this]() { } } -rai::wallets::~wallets () +nano::wallets::~wallets () { stop (); } -std::shared_ptr rai::wallets::open (rai::uint256_union const & id_a) +std::shared_ptr nano::wallets::open (nano::uint256_union const & id_a) { - std::shared_ptr result; + std::shared_ptr result; auto existing (items.find (id_a)); if (existing != items.end ()) { @@ -1299,14 +1299,14 @@ std::shared_ptr rai::wallets::open (rai::uint256_union const & id_a return result; } -std::shared_ptr rai::wallets::create (rai::uint256_union const & id_a) +std::shared_ptr nano::wallets::create (nano::uint256_union const & id_a) { assert (items.find (id_a) == items.end ()); - std::shared_ptr result; + std::shared_ptr result; bool error; { auto transaction (node.store.tx_begin_write ()); - result = std::make_shared (error, transaction, *this, id_a.to_string ()); + result = std::make_shared (error, transaction, *this, id_a.to_string ()); } if (!error) { @@ -1316,7 +1316,7 @@ std::shared_ptr rai::wallets::create (rai::uint256_union const & id return result; } -bool rai::wallets::search_pending (rai::uint256_union const & wallet_a) +bool nano::wallets::search_pending (nano::uint256_union const & wallet_a) { auto result (false); auto existing (items.find (wallet_a)); @@ -1329,7 +1329,7 @@ bool rai::wallets::search_pending (rai::uint256_union const & wallet_a) return result; } -void rai::wallets::search_pending_all () +void nano::wallets::search_pending_all () { for (auto i : items) { @@ -1337,7 +1337,7 @@ void rai::wallets::search_pending_all () } } -void rai::wallets::destroy (rai::uint256_union const & id_a) +void nano::wallets::destroy (nano::uint256_union const & id_a) { std::lock_guard lock (mutex); auto transaction (node.store.tx_begin_write ()); @@ -1348,7 +1348,7 @@ void rai::wallets::destroy (rai::uint256_union const & id_a) wallet->store.destroy (transaction); } -void rai::wallets::do_wallet_actions () +void nano::wallets::do_wallet_actions () { std::unique_lock lock (mutex); while (!stopped) @@ -1375,7 +1375,7 @@ void rai::wallets::do_wallet_actions () } } -void rai::wallets::queue_wallet_action (rai::uint128_t const & amount_a, std::shared_ptr wallet_a, std::function const & action_a) +void nano::wallets::queue_wallet_action (nano::uint128_t const & amount_a, std::shared_ptr wallet_a, std::function const & action_a) { { std::lock_guard lock (mutex); @@ -1384,22 +1384,22 @@ void rai::wallets::queue_wallet_action (rai::uint128_t const & amount_a, std::sh condition.notify_all (); } -void rai::wallets::foreach_representative (rai::transaction const & transaction_a, std::function const & action_a) +void nano::wallets::foreach_representative (nano::transaction const & transaction_a, std::function const & action_a) { for (auto i (items.begin ()), n (items.end ()); i != n; ++i) { auto & wallet (*i->second); for (auto j (wallet.store.begin (transaction_a)), m (wallet.store.end ()); j != m; ++j) { - rai::account account (j->first); + nano::account account (j->first); if (!node.ledger.weight (transaction_a, account).is_zero ()) { if (wallet.store.valid_password (transaction_a)) { - rai::raw_key prv; - auto error (wallet.store.fetch (transaction_a, rai::uint256_union (j->first), prv)); + nano::raw_key prv; + auto error (wallet.store.fetch (transaction_a, nano::uint256_union (j->first), prv)); assert (!error); - action_a (rai::uint256_union (j->first), prv); + action_a (nano::uint256_union (j->first), prv); } else { @@ -1415,7 +1415,7 @@ void rai::wallets::foreach_representative (rai::transaction const & transaction_ } } -bool rai::wallets::exists (rai::transaction const & transaction_a, rai::public_key const & account_a) +bool nano::wallets::exists (nano::transaction const & transaction_a, nano::public_key const & account_a) { auto result (false); for (auto i (items.begin ()), n (items.end ()); !result && i != n; ++i) @@ -1425,7 +1425,7 @@ bool rai::wallets::exists (rai::transaction const & transaction_a, rai::public_k return result; } -void rai::wallets::stop () +void nano::wallets::stop () { { std::lock_guard lock (mutex); @@ -1439,49 +1439,49 @@ void rai::wallets::stop () } } -rai::transaction rai::wallets::tx_begin_write () +nano::transaction nano::wallets::tx_begin_write () { return tx_begin (true); } -rai::transaction rai::wallets::tx_begin_read () +nano::transaction nano::wallets::tx_begin_read () { return tx_begin (false); } -rai::transaction rai::wallets::tx_begin (bool write_a) +nano::transaction nano::wallets::tx_begin (bool write_a) { return env.tx_begin (write_a); } -void rai::wallets::clear_send_ids (rai::transaction const & transaction_a) +void nano::wallets::clear_send_ids (nano::transaction const & transaction_a) { auto status (mdb_drop (env.tx (transaction_a), send_action_ids, 0)); assert (status == 0); } -rai::uint128_t const rai::wallets::generate_priority = std::numeric_limits::max (); -rai::uint128_t const rai::wallets::high_priority = std::numeric_limits::max () - 1; +nano::uint128_t const nano::wallets::generate_priority = std::numeric_limits::max (); +nano::uint128_t const nano::wallets::high_priority = std::numeric_limits::max () - 1; -rai::store_iterator rai::wallet_store::begin (rai::transaction const & transaction_a) +nano::store_iterator nano::wallet_store::begin (nano::transaction const & transaction_a) { - rai::store_iterator result (std::make_unique> (transaction_a, handle, rai::mdb_val (rai::uint256_union (special_count)))); + nano::store_iterator result (std::make_unique> (transaction_a, handle, nano::mdb_val (nano::uint256_union (special_count)))); return result; } -rai::store_iterator rai::wallet_store::begin (rai::transaction const & transaction_a, rai::uint256_union const & key) +nano::store_iterator nano::wallet_store::begin (nano::transaction const & transaction_a, nano::uint256_union const & key) { - rai::store_iterator result (std::make_unique> (transaction_a, handle, rai::mdb_val (key))); + nano::store_iterator result (std::make_unique> (transaction_a, handle, nano::mdb_val (key))); return result; } -rai::store_iterator rai::wallet_store::find (rai::transaction const & transaction_a, rai::uint256_union const & key) +nano::store_iterator nano::wallet_store::find (nano::transaction const & transaction_a, nano::uint256_union const & key) { auto result (begin (transaction_a, key)); - rai::store_iterator end (nullptr); + nano::store_iterator end (nullptr); if (result != end) { - if (rai::uint256_union (result->first) == key) + if (nano::uint256_union (result->first) == key) { return result; } @@ -1497,13 +1497,13 @@ rai::store_iterator rai::wallet_store::fi return result; } -rai::store_iterator rai::wallet_store::end () +nano::store_iterator nano::wallet_store::end () { - return rai::store_iterator (nullptr); + return nano::store_iterator (nullptr); } -MDB_txn * rai::wallet_store::tx (rai::transaction const & transaction_a) const +MDB_txn * nano::wallet_store::tx (nano::transaction const & transaction_a) const { - auto result (boost::polymorphic_downcast (transaction_a.impl.get ())); + auto result (boost::polymorphic_downcast (transaction_a.impl.get ())); return *result; } diff --git a/nano/node/wallet.hpp b/nano/node/wallet.hpp new file mode 100644 index 00000000..6debd938 --- /dev/null +++ b/nano/node/wallet.hpp @@ -0,0 +1,208 @@ +#pragma once + +#include +#include +#include +#include +#include +#include + +#include +#include +#include +#include + +namespace nano +{ +// The fan spreads a key out over the heap to decrease the likelihood of it being recovered by memory inspection +class fan +{ +public: + fan (nano::uint256_union const &, size_t); + void value (nano::raw_key &); + void value_set (nano::raw_key const &); + std::vector> values; + +private: + std::mutex mutex; + void value_get (nano::raw_key &); +}; +class node_config; +class kdf +{ +public: + void phs (nano::raw_key &, std::string const &, nano::uint256_union const &); + std::mutex mutex; +}; +enum class key_type +{ + not_a_type, + unknown, + adhoc, + deterministic +}; +class wallet_store +{ +public: + wallet_store (bool &, nano::kdf &, nano::transaction &, nano::account, unsigned, std::string const &); + wallet_store (bool &, nano::kdf &, nano::transaction &, nano::account, unsigned, std::string const &, std::string const &); + std::vector accounts (nano::transaction const &); + void initialize (nano::transaction const &, bool &, std::string const &); + nano::uint256_union check (nano::transaction const &); + bool rekey (nano::transaction const &, std::string const &); + bool valid_password (nano::transaction const &); + bool attempt_password (nano::transaction const &, std::string const &); + void wallet_key (nano::raw_key &, nano::transaction const &); + void seed (nano::raw_key &, nano::transaction const &); + void seed_set (nano::transaction const &, nano::raw_key const &); + nano::key_type key_type (nano::wallet_value const &); + nano::public_key deterministic_insert (nano::transaction const &); + void deterministic_key (nano::raw_key &, nano::transaction const &, uint32_t); + uint32_t deterministic_index_get (nano::transaction const &); + void deterministic_index_set (nano::transaction const &, uint32_t); + void deterministic_clear (nano::transaction const &); + nano::uint256_union salt (nano::transaction const &); + bool is_representative (nano::transaction const &); + nano::account representative (nano::transaction const &); + void representative_set (nano::transaction const &, nano::account const &); + nano::public_key insert_adhoc (nano::transaction const &, nano::raw_key const &); + void insert_watch (nano::transaction const &, nano::public_key const &); + void erase (nano::transaction const &, nano::public_key const &); + nano::wallet_value entry_get_raw (nano::transaction const &, nano::public_key const &); + void entry_put_raw (nano::transaction const &, nano::public_key const &, nano::wallet_value const &); + bool fetch (nano::transaction const &, nano::public_key const &, nano::raw_key &); + bool exists (nano::transaction const &, nano::public_key const &); + void destroy (nano::transaction const &); + nano::store_iterator find (nano::transaction const &, nano::uint256_union const &); + nano::store_iterator begin (nano::transaction const &, nano::uint256_union const &); + nano::store_iterator begin (nano::transaction const &); + nano::store_iterator end (); + void derive_key (nano::raw_key &, nano::transaction const &, std::string const &); + void serialize_json (nano::transaction const &, std::string &); + void write_backup (nano::transaction const &, boost::filesystem::path const &); + bool move (nano::transaction const &, nano::wallet_store &, std::vector const &); + bool import (nano::transaction const &, nano::wallet_store &); + bool work_get (nano::transaction const &, nano::public_key const &, uint64_t &); + void work_put (nano::transaction const &, nano::public_key const &, uint64_t); + unsigned version (nano::transaction const &); + void version_put (nano::transaction const &, unsigned); + void upgrade_v1_v2 (nano::transaction const &); + void upgrade_v2_v3 (nano::transaction const &); + void upgrade_v3_v4 (nano::transaction const &); + nano::fan password; + nano::fan wallet_key_mem; + static unsigned const version_1 = 1; + static unsigned const version_2 = 2; + static unsigned const version_3 = 3; + static unsigned const version_4 = 4; + unsigned const version_current = version_4; + static nano::uint256_union const version_special; + static nano::uint256_union const wallet_key_special; + static nano::uint256_union const salt_special; + static nano::uint256_union const check_special; + static nano::uint256_union const representative_special; + static nano::uint256_union const seed_special; + static nano::uint256_union const deterministic_index_special; + static size_t const check_iv_index; + static size_t const seed_iv_index; + static int const special_count; + static unsigned const kdf_full_work = 64 * 1024; + static unsigned const kdf_test_work = 8; + static unsigned const kdf_work = nano::nano_network == nano::nano_networks::nano_test_network ? kdf_test_work : kdf_full_work; + nano::kdf & kdf; + MDB_dbi handle; + std::recursive_mutex mutex; + +private: + MDB_txn * tx (nano::transaction const &) const; +}; +class wallets; +// A wallet is a set of account keys encrypted by a common encryption key +class wallet : public std::enable_shared_from_this +{ +public: + std::shared_ptr change_action (nano::account const &, nano::account const &, bool = true); + std::shared_ptr receive_action (nano::block const &, nano::account const &, nano::uint128_union const &, bool = true); + std::shared_ptr send_action (nano::account const &, nano::account const &, nano::uint128_t const &, bool = true, boost::optional = {}); + wallet (bool &, nano::transaction &, nano::wallets &, std::string const &); + wallet (bool &, nano::transaction &, nano::wallets &, std::string const &, std::string const &); + void enter_initial_password (); + bool enter_password (nano::transaction const &, std::string const &); + nano::public_key insert_adhoc (nano::raw_key const &, bool = true); + nano::public_key insert_adhoc (nano::transaction const &, nano::raw_key const &, bool = true); + void insert_watch (nano::transaction const &, nano::public_key const &); + nano::public_key deterministic_insert (nano::transaction const &, bool = true); + nano::public_key deterministic_insert (bool = true); + bool exists (nano::public_key const &); + bool import (std::string const &, std::string const &); + void serialize (std::string &); + bool change_sync (nano::account const &, nano::account const &); + void change_async (nano::account const &, nano::account const &, std::function)> const &, bool = true); + bool receive_sync (std::shared_ptr, nano::account const &, nano::uint128_t const &); + void receive_async (std::shared_ptr, nano::account const &, nano::uint128_t const &, std::function)> const &, bool = true); + nano::block_hash send_sync (nano::account const &, nano::account const &, nano::uint128_t const &); + void send_async (nano::account const &, nano::account const &, nano::uint128_t const &, std::function)> const &, bool = true, boost::optional = {}); + void work_apply (nano::account const &, std::function); + void work_cache_blocking (nano::account const &, nano::block_hash const &); + void work_update (nano::transaction const &, nano::account const &, nano::block_hash const &, uint64_t); + void work_ensure (nano::account const &, nano::block_hash const &); + bool search_pending (); + void init_free_accounts (nano::transaction const &); + /** Changes the wallet seed and returns the first account */ + nano::public_key change_seed (nano::transaction const & transaction_a, nano::raw_key const & prv_a); + bool live (); + std::unordered_set free_accounts; + std::function lock_observer; + nano::wallet_store store; + nano::wallets & wallets; +}; +class node; + +/** + * The wallets set is all the wallets a node controls. + * A node may contain multiple wallets independently encrypted and operated. + */ +class wallets +{ +public: + wallets (bool &, nano::node &); + ~wallets (); + std::shared_ptr open (nano::uint256_union const &); + std::shared_ptr create (nano::uint256_union const &); + bool search_pending (nano::uint256_union const &); + void search_pending_all (); + void destroy (nano::uint256_union const &); + void do_wallet_actions (); + void queue_wallet_action (nano::uint128_t const &, std::shared_ptr, std::function const &); + void foreach_representative (nano::transaction const &, std::function const &); + bool exists (nano::transaction const &, nano::public_key const &); + void stop (); + void clear_send_ids (nano::transaction const &); + std::function observer; + std::unordered_map> items; + std::multimap, std::function>, std::greater> actions; + std::mutex mutex; + std::condition_variable condition; + nano::kdf kdf; + MDB_dbi handle; + MDB_dbi send_action_ids; + nano::node & node; + nano::mdb_env & env; + bool stopped; + boost::thread thread; + static nano::uint128_t const generate_priority; + static nano::uint128_t const high_priority; + + /** Start read-write transaction */ + nano::transaction tx_begin_write (); + + /** Start read-only transaction */ + nano::transaction tx_begin_read (); + + /** + * Start a read-only or read-write transaction + * @param write If true, start a read-write transaction + */ + nano::transaction tx_begin (bool write = false); +}; +} diff --git a/rai/node/working.hpp b/nano/node/working.hpp similarity index 53% rename from rai/node/working.hpp rename to nano/node/working.hpp index e756ef04..8480d37a 100644 --- a/rai/node/working.hpp +++ b/nano/node/working.hpp @@ -1,8 +1,8 @@ #pragma once -#include +#include -namespace rai +namespace nano { boost::filesystem::path app_path (); } diff --git a/rai/node/xorshift.hpp b/nano/node/xorshift.hpp similarity index 96% rename from rai/node/xorshift.hpp rename to nano/node/xorshift.hpp index ce3d5544..3f0b7993 100644 --- a/rai/node/xorshift.hpp +++ b/nano/node/xorshift.hpp @@ -1,7 +1,7 @@ #pragma once #include -namespace rai +namespace nano { class xorshift1024star { diff --git a/rai/qt/qt.cpp b/nano/qt/qt.cpp similarity index 89% rename from rai/qt/qt.cpp rename to nano/qt/qt.cpp index ae60cb85..3dccbbbe 100644 --- a/rai/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -1,4 +1,4 @@ -#include +#include #include #include @@ -43,20 +43,20 @@ void show_button_success (QPushButton & button) } } -bool rai_qt::eventloop_processor::event (QEvent * event_a) +bool nano_qt::eventloop_processor::event (QEvent * event_a) { - assert (dynamic_cast (event_a) != nullptr); - static_cast (event_a)->action (); + assert (dynamic_cast (event_a) != nullptr); + static_cast (event_a)->action (); return true; } -rai_qt::eventloop_event::eventloop_event (std::function const & action_a) : +nano_qt::eventloop_event::eventloop_event (std::function const & action_a) : QEvent (QEvent::Type::User), action (action_a) { } -rai_qt::self_pane::self_pane (rai_qt::wallet & wallet_a, rai::account const & account_a) : +nano_qt::self_pane::self_pane (nano_qt::wallet & wallet_a, nano::account const & account_a) : window (new QWidget), layout (new QVBoxLayout), self_layout (new QHBoxLayout), @@ -72,7 +72,7 @@ balance_label (new QLabel), wallet (wallet_a) { your_account_label->setStyleSheet ("font-weight: bold;"); - version = new QLabel (boost::str (boost::format ("Version %1%.%2%") % RAIBLOCKS_VERSION_MAJOR % RAIBLOCKS_VERSION_MINOR).c_str ()); + version = new QLabel (boost::str (boost::format ("Version %1%.%2%") % NANO_VERSION_MAJOR % NANO_VERSION_MINOR).c_str ()); self_layout->addWidget (your_account_label); self_layout->addStretch (); self_layout->addWidget (version); @@ -106,7 +106,7 @@ wallet (wallet_a) }); } -void rai_qt::self_pane::set_balance_text (std::pair balance_a) +void nano_qt::self_pane::set_balance_text (std::pair balance_a) { auto final_text (std::string ("Balance: ") + wallet.format_balance (balance_a.first)); if (!balance_a.second.is_zero ()) @@ -116,7 +116,7 @@ void rai_qt::self_pane::set_balance_text (std::pairsetText (QString (final_text.c_str ())); } -rai_qt::accounts::accounts (rai_qt::wallet & wallet_a) : +nano_qt::accounts::accounts (nano_qt::wallet & wallet_a) : wallet_balance_label (new QLabel), window (new QWidget), layout (new QVBoxLayout), @@ -165,7 +165,7 @@ wallet (wallet_a) QObject::connect (account_key_button, &QPushButton::released, [this]() { QString key_text_wide (account_key_line->text ()); std::string key_text (key_text_wide.toLocal8Bit ()); - rai::raw_key key; + nano::raw_key key; if (!key.data.decode_hex (key_text)) { show_line_ok (*account_key_line); @@ -214,7 +214,7 @@ wallet (wallet_a) this->wallet.push_main_stack (this->wallet.import.window); }); QObject::connect (backup_seed, &QPushButton::released, [this]() { - rai::raw_key seed; + nano::raw_key seed; auto transaction (this->wallet.wallet_m->wallets.tx_begin_read ()); if (this->wallet.wallet_m->store.valid_password (transaction)) { @@ -250,14 +250,14 @@ wallet (wallet_a) refresh_wallet_balance (); } -void rai_qt::accounts::refresh_wallet_balance () +void nano_qt::accounts::refresh_wallet_balance () { auto transaction (this->wallet.wallet_m->wallets.tx_begin_read ()); - rai::uint128_t balance (0); - rai::uint128_t pending (0); + nano::uint128_t balance (0); + nano::uint128_t pending (0); for (auto i (this->wallet.wallet_m->store.begin (transaction)), j (this->wallet.wallet_m->store.end ()); i != j; ++i) { - rai::public_key key (i->first); + nano::public_key key (i->first); balance = balance + (this->wallet.node.ledger.account_balance (transaction, key)); pending = pending + (this->wallet.node.ledger.account_pending (transaction, key)); } @@ -274,19 +274,19 @@ void rai_qt::accounts::refresh_wallet_balance () }); } -void rai_qt::accounts::refresh () +void nano_qt::accounts::refresh () { model->removeRows (0, model->rowCount ()); auto transaction (wallet.wallet_m->wallets.tx_begin_read ()); QBrush brush; for (auto i (wallet.wallet_m->store.begin (transaction)), j (wallet.wallet_m->store.end ()); i != j; ++i) { - rai::public_key key (i->first); + nano::public_key key (i->first); auto balance_amount (wallet.node.ledger.account_balance (transaction, key)); bool display (true); switch (wallet.wallet_m->store.key_type (i->second)) { - case rai::key_type::adhoc: + case nano::key_type::adhoc: { brush.setColor ("red"); display = !balance_amount.is_zero (); @@ -311,7 +311,7 @@ void rai_qt::accounts::refresh () } } -rai_qt::import::import (rai_qt::wallet & wallet_a) : +nano_qt::import::import (nano_qt::wallet & wallet_a) : window (new QWidget), layout (new QVBoxLayout), seed_label (new QLabel ("Seed:")), @@ -375,7 +375,7 @@ wallet (wallet_a) if (clear_line->text ().toStdString () == "clear keys") { show_line_ok (*clear_line); - rai::raw_key seed_l; + nano::raw_key seed_l; if (!seed_l.data.decode_hex (seed->text ().toStdString ())) { bool successful (false); @@ -461,7 +461,7 @@ wallet (wallet_a) }); } -rai_qt::history::history (rai::ledger & ledger_a, rai::account const & account_a, rai_qt::wallet & wallet_a) : +nano_qt::history::history (nano::ledger & ledger_a, nano::account const & account_a, nano_qt::wallet & wallet_a) : window (new QWidget), layout (new QVBoxLayout), model (new QStandardItemModel), @@ -496,47 +496,47 @@ wallet (wallet_a) namespace { -class short_text_visitor : public rai::block_visitor +class short_text_visitor : public nano::block_visitor { public: - short_text_visitor (rai::transaction const & transaction_a, rai::ledger & ledger_a) : + short_text_visitor (nano::transaction const & transaction_a, nano::ledger & ledger_a) : transaction (transaction_a), ledger (ledger_a) { } - void send_block (rai::send_block const & block_a) + void send_block (nano::send_block const & block_a) { type = "Send"; account = block_a.hashables.destination; amount = ledger.amount (transaction, block_a.hash ()); } - void receive_block (rai::receive_block const & block_a) + void receive_block (nano::receive_block const & block_a) { type = "Receive"; account = ledger.account (transaction, block_a.source ()); amount = ledger.amount (transaction, block_a.source ()); } - void open_block (rai::open_block const & block_a) + void open_block (nano::open_block const & block_a) { type = "Receive"; - if (block_a.hashables.source != rai::genesis_account) + if (block_a.hashables.source != nano::genesis_account) { account = ledger.account (transaction, block_a.hashables.source); amount = ledger.amount (transaction, block_a.hash ()); } else { - account = rai::genesis_account; - amount = rai::genesis_amount; + account = nano::genesis_account; + amount = nano::genesis_amount; } } - void change_block (rai::change_block const & block_a) + void change_block (nano::change_block const & block_a) { type = "Change"; amount = 0; account = block_a.hashables.representative; } - void state_block (rai::state_block const & block_a) + void state_block (nano::state_block const & block_a) { auto balance (block_a.hashables.balance.number ()); auto previous_balance (ledger.balance (transaction, block_a.hashables.previous)); @@ -566,15 +566,15 @@ public: amount = balance - previous_balance; } } - rai::transaction const & transaction; - rai::ledger & ledger; + nano::transaction const & transaction; + nano::ledger & ledger; std::string type; - rai::uint128_t amount; - rai::account account; + nano::uint128_t amount; + nano::account account; }; } -void rai_qt::history::refresh () +void nano_qt::history::refresh () { auto transaction (ledger.store.tx_begin_read ()); model->removeRows (0, model->rowCount ()); @@ -597,7 +597,7 @@ void rai_qt::history::refresh () } } -rai_qt::block_viewer::block_viewer (rai_qt::wallet & wallet_a) : +nano_qt::block_viewer::block_viewer (nano_qt::wallet & wallet_a) : window (new QWidget), layout (new QVBoxLayout), hash_label (new QLabel ("Hash:")), @@ -626,7 +626,7 @@ wallet (wallet_a) this->wallet.pop_main_stack (); }); QObject::connect (retrieve, &QPushButton::released, [this]() { - rai::block_hash hash_l; + nano::block_hash hash_l; if (!hash_l.decode_hex (hash->text ().toStdString ())) { auto transaction (this->wallet.node.store.tx_begin_read ()); @@ -650,7 +650,7 @@ wallet (wallet_a) } }); QObject::connect (rebroadcast, &QPushButton::released, [this]() { - rai::block_hash block; + nano::block_hash block; auto error (block.decode_hex (hash->text ().toStdString ())); if (!error) { @@ -672,7 +672,7 @@ wallet (wallet_a) rebroadcast->setToolTip ("Rebroadcast block into the network"); } -void rai_qt::block_viewer::rebroadcast_action (rai::uint256_union const & hash_a) +void nano_qt::block_viewer::rebroadcast_action (nano::uint256_union const & hash_a) { auto done (true); auto transaction (wallet.node.ledger.store.tx_begin_read ()); @@ -697,7 +697,7 @@ void rai_qt::block_viewer::rebroadcast_action (rai::uint256_union const & hash_a } } -rai_qt::account_viewer::account_viewer (rai_qt::wallet & wallet_a) : +nano_qt::account_viewer::account_viewer (nano_qt::wallet & wallet_a) : window (new QWidget), layout (new QVBoxLayout), account_label (new QLabel ("Account:")), @@ -752,7 +752,7 @@ wallet (wallet_a) }); } -rai_qt::stats_viewer::stats_viewer (rai_qt::wallet & wallet_a) : +nano_qt::stats_viewer::stats_viewer (nano_qt::wallet & wallet_a) : window (new QWidget), layout (new QVBoxLayout), refresh (new QPushButton ("Refresh")), @@ -786,7 +786,7 @@ wallet (wallet_a) refresh_stats (); } -void rai_qt::stats_viewer::refresh_stats () +void nano_qt::stats_viewer::refresh_stats () { model->removeRows (0, model->rowCount ()); @@ -836,36 +836,36 @@ void rai_qt::stats_viewer::refresh_stats () } } -rai_qt::status::status (rai_qt::wallet & wallet_a) : +nano_qt::status::status (nano_qt::wallet & wallet_a) : wallet (wallet_a) { wallet.status->setToolTip ("Wallet status, block count (blocks downloaded)"); - active.insert (rai_qt::status_types::nominal); + active.insert (nano_qt::status_types::nominal); set_text (); } -void rai_qt::status::erase (rai_qt::status_types status_a) +void nano_qt::status::erase (nano_qt::status_types status_a) { - assert (status_a != rai_qt::status_types::nominal); + assert (status_a != nano_qt::status_types::nominal); auto erased (active.erase (status_a)); (void)erased; set_text (); } -void rai_qt::status::insert (rai_qt::status_types status_a) +void nano_qt::status::insert (nano_qt::status_types status_a) { - assert (status_a != rai_qt::status_types::nominal); + assert (status_a != nano_qt::status_types::nominal); active.insert (status_a); set_text (); } -void rai_qt::status::set_text () +void nano_qt::status::set_text () { wallet.status->setText (text ().c_str ()); wallet.status->setStyleSheet ((std::string ("QLabel {") + color () + "}").c_str ()); } -std::string rai_qt::status::text () +std::string nano_qt::status::text () { assert (!active.empty ()); std::string result; @@ -880,25 +880,25 @@ std::string rai_qt::status::text () switch (*active.begin ()) { - case rai_qt::status_types::disconnected: + case nano_qt::status_types::disconnected: result = "Status: Disconnected"; break; - case rai_qt::status_types::working: + case nano_qt::status_types::working: result = "Status: Generating proof of work"; break; - case rai_qt::status_types::synchronizing: + case nano_qt::status_types::synchronizing: result = "Status: Synchronizing"; break; - case rai_qt::status_types::locked: + case nano_qt::status_types::locked: result = "Status: Wallet locked"; break; - case rai_qt::status_types::vulnerable: + case nano_qt::status_types::vulnerable: result = "Status: Wallet password empty"; break; - case rai_qt::status_types::active: + case nano_qt::status_types::active: result = "Status: Wallet active"; break; - case rai_qt::status_types::nominal: + case nano_qt::status_types::nominal: result = "Status: Running"; break; default: @@ -916,31 +916,31 @@ std::string rai_qt::status::text () return result; } -std::string rai_qt::status::color () +std::string nano_qt::status::color () { assert (!active.empty ()); std::string result; switch (*active.begin ()) { - case rai_qt::status_types::disconnected: + case nano_qt::status_types::disconnected: result = "color: red"; break; - case rai_qt::status_types::working: + case nano_qt::status_types::working: result = "color: blue"; break; - case rai_qt::status_types::synchronizing: + case nano_qt::status_types::synchronizing: result = "color: blue"; break; - case rai_qt::status_types::locked: + case nano_qt::status_types::locked: result = "color: orange"; break; - case rai_qt::status_types::vulnerable: + case nano_qt::status_types::vulnerable: result = "color: blue"; break; - case rai_qt::status_types::active: + case nano_qt::status_types::active: result = "color: black"; break; - case rai_qt::status_types::nominal: + case nano_qt::status_types::nominal: result = "color: black"; break; default: @@ -950,8 +950,8 @@ std::string rai_qt::status::color () return result; } -rai_qt::wallet::wallet (QApplication & application_a, rai_qt::eventloop_processor & processor_a, rai::node & node_a, std::shared_ptr wallet_a, rai::account & account_a) : -rendering_ratio (rai::Mxrb_ratio), +nano_qt::wallet::wallet (QApplication & application_a, nano_qt::eventloop_processor & processor_a, nano::node & node_a, std::shared_ptr wallet_a, nano::account & account_a) : +rendering_ratio (nano::Mxrb_ratio), node (node_a), wallet_m (wallet_a), account (account_a), @@ -994,7 +994,7 @@ active_status (*this) empty_password (); settings.update_locked (true, true); send_blocks_layout->addWidget (send_account_label); - send_account->setPlaceholderText (rai::zero_key.pub.to_account ().c_str ()); + send_account->setPlaceholderText (nano::zero_key.pub.to_account ().c_str ()); send_blocks_layout->addWidget (send_account); send_blocks_layout->addWidget (send_count_label); send_count->setPlaceholderText ("0"); @@ -1045,9 +1045,9 @@ active_status (*this) refresh (); } -void rai_qt::wallet::ongoing_refresh () +void nano_qt::wallet::ongoing_refresh () { - std::weak_ptr wallet_w (shared_from_this ()); + std::weak_ptr wallet_w (shared_from_this ()); // Update balance if needed. This happens on an alarm thread, which posts back to the UI // to do the actual rendering. This avoid UI lockups as balance_pending may take several @@ -1080,10 +1080,10 @@ void rai_qt::wallet::ongoing_refresh () }); } -void rai_qt::wallet::start () +void nano_qt::wallet::start () { ongoing_refresh (); - std::weak_ptr this_w (shared_from_this ()); + std::weak_ptr this_w (shared_from_this ()); QObject::connect (settings_button, &QPushButton::released, [this_w]() { if (auto this_l = this_w.lock ()) { @@ -1107,15 +1107,15 @@ void rai_qt::wallet::start () { show_line_ok (*this_l->send_count); show_line_ok (*this_l->send_account); - rai::amount amount; + nano::amount amount; if (!amount.decode_dec (this_l->send_count->text ().toStdString ())) { - rai::uint128_t actual (amount.number () * this_l->rendering_ratio); + nano::uint128_t actual (amount.number () * this_l->rendering_ratio); if (actual / this_l->rendering_ratio == amount.number ()) { QString account_text (this_l->send_account->text ()); std::string account_text_narrow (account_text.toLocal8Bit ()); - rai::account account_l; + nano::account account_l; auto parse_error (account_l.decode_account (account_text_narrow)); if (!parse_error) { @@ -1129,7 +1129,7 @@ void rai_qt::wallet::start () this_l->node.background ([this_w, account_l, actual]() { if (auto this_l = this_w.lock ()) { - this_l->wallet_m->send_async (this_l->account, account_l, actual, [this_w](std::shared_ptr block_a) { + this_l->wallet_m->send_async (this_l->account, account_l, actual, [this_w](std::shared_ptr block_a) { if (auto this_l = this_w.lock ()) { auto succeeded (block_a != nullptr); @@ -1265,7 +1265,7 @@ void rai_qt::wallet::start () this_l->push_main_stack (this_l->send_blocks_window); } }); - node.observers.blocks.add ([this_w](std::shared_ptr block_a, rai::account const & account_a, rai::uint128_t const & amount_a, bool) { + node.observers.blocks.add ([this_w](std::shared_ptr block_a, nano::account const & account_a, nano::uint128_t const & amount_a, bool) { if (auto this_l = this_w.lock ()) { this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w, block_a, account_a]() { @@ -1283,7 +1283,7 @@ void rai_qt::wallet::start () })); } }); - node.observers.account_balance.add ([this_w](rai::account const & account_a, bool is_pending) { + node.observers.account_balance.add ([this_w](nano::account const & account_a, bool is_pending) { if (auto this_l = this_w.lock ()) { this_l->needs_balance_refresh = this_l->needs_balance_refresh || account_a == this_l->account; @@ -1297,17 +1297,17 @@ void rai_qt::wallet::start () { if (active_a) { - this_l->active_status.insert (rai_qt::status_types::active); + this_l->active_status.insert (nano_qt::status_types::active); } else { - this_l->active_status.erase (rai_qt::status_types::active); + this_l->active_status.erase (nano_qt::status_types::active); } } })); } }); - node.observers.endpoint.add ([this_w](rai::endpoint const &) { + node.observers.endpoint.add ([this_w](nano::endpoint const &) { if (auto this_l = this_w.lock ()) { this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w]() { @@ -1337,11 +1337,11 @@ void rai_qt::wallet::start () { if (active_a) { - this_l->active_status.insert (rai_qt::status_types::synchronizing); + this_l->active_status.insert (nano_qt::status_types::synchronizing); } else { - this_l->active_status.erase (rai_qt::status_types::synchronizing); + this_l->active_status.erase (nano_qt::status_types::synchronizing); } } })); @@ -1355,11 +1355,11 @@ void rai_qt::wallet::start () { if (working) { - this_l->active_status.insert (rai_qt::status_types::working); + this_l->active_status.insert (nano_qt::status_types::working); } else { - this_l->active_status.erase (rai_qt::status_types::working); + this_l->active_status.erase (nano_qt::status_types::working); } } })); @@ -1379,7 +1379,7 @@ void rai_qt::wallet::start () settings_button->setToolTip ("Unlock wallet, set password, change representative"); } -void rai_qt::wallet::refresh () +void nano_qt::wallet::refresh () { { auto transaction (wallet_m->wallets.tx_begin_read ()); @@ -1393,19 +1393,19 @@ void rai_qt::wallet::refresh () settings.refresh_representative (); } -void rai_qt::wallet::update_connected () +void nano_qt::wallet::update_connected () { if (node.peers.empty ()) { - active_status.insert (rai_qt::status_types::disconnected); + active_status.insert (nano_qt::status_types::disconnected); } else { - active_status.erase (rai_qt::status_types::disconnected); + active_status.erase (nano_qt::status_types::disconnected); } } -void rai_qt::wallet::empty_password () +void nano_qt::wallet::empty_password () { this->node.alarm.add (std::chrono::steady_clock::now () + std::chrono::seconds (3), [this]() { auto transaction (wallet_m->wallets.tx_begin_write ()); @@ -1413,7 +1413,7 @@ void rai_qt::wallet::empty_password () }); } -void rai_qt::wallet::change_rendering_ratio (rai::uint128_t const & rendering_ratio_a) +void nano_qt::wallet::change_rendering_ratio (nano::uint128_t const & rendering_ratio_a) { application.postEvent (&processor, new eventloop_event ([this, rendering_ratio_a]() { this->rendering_ratio = rendering_ratio_a; @@ -1421,33 +1421,33 @@ void rai_qt::wallet::change_rendering_ratio (rai::uint128_t const & rendering_ra })); } -std::string rai_qt::wallet::format_balance (rai::uint128_t const & balance) const +std::string nano_qt::wallet::format_balance (nano::uint128_t const & balance) const { - auto balance_str = rai::amount (balance).format_balance (rendering_ratio, 0, false); + auto balance_str = nano::amount (balance).format_balance (rendering_ratio, 0, false); auto unit = std::string ("NANO"); - if (rendering_ratio == rai::kxrb_ratio) + if (rendering_ratio == nano::kxrb_ratio) { unit = std::string ("knano"); } - else if (rendering_ratio == rai::xrb_ratio) + else if (rendering_ratio == nano::xrb_ratio) { unit = std::string ("nano"); } return balance_str + " " + unit; } -void rai_qt::wallet::push_main_stack (QWidget * widget_a) +void nano_qt::wallet::push_main_stack (QWidget * widget_a) { main_stack->addWidget (widget_a); main_stack->setCurrentIndex (main_stack->count () - 1); } -void rai_qt::wallet::pop_main_stack () +void nano_qt::wallet::pop_main_stack () { main_stack->removeWidget (main_stack->currentWidget ()); } -rai_qt::settings::settings (rai_qt::wallet & wallet_a) : +nano_qt::settings::settings (nano_qt::wallet & wallet_a) : window (new QWidget), layout (new QVBoxLayout), password (new QLineEdit), @@ -1484,7 +1484,7 @@ wallet (wallet_a) layout->addWidget (representative); current_representative->setTextInteractionFlags (Qt::TextSelectableByMouse); layout->addWidget (current_representative); - new_representative->setPlaceholderText (rai::zero_key.pub.to_account ().c_str ()); + new_representative->setPlaceholderText (nano::zero_key.pub.to_account ().c_str ()); layout->addWidget (new_representative); layout->addWidget (change_rep); layout->addStretch (); @@ -1539,7 +1539,7 @@ wallet (wallet_a) } }); QObject::connect (change_rep, &QPushButton::released, [this]() { - rai::account representative_l; + nano::account representative_l; if (!representative_l.decode_account (new_representative->text ().toStdString ())) { auto transaction (this->wallet.wallet_m->wallets.tx_begin_read ()); @@ -1598,7 +1598,7 @@ wallet (wallet_a) if (this->wallet.wallet_m->store.valid_password (transaction)) { // lock wallet - rai::raw_key empty; + nano::raw_key empty; empty.data.clear (); this->wallet.wallet_m->store.password.value_set (empty); update_locked (true, true); @@ -1653,10 +1653,10 @@ wallet (wallet_a) refresh_representative (); } -void rai_qt::settings::refresh_representative () +void nano_qt::settings::refresh_representative () { auto transaction (this->wallet.wallet_m->wallets.node.store.tx_begin_read ()); - rai::account_info info; + nano::account_info info; auto error (wallet.node.store.account_get (transaction, this->wallet.account, info)); if (!error) { @@ -1670,32 +1670,32 @@ void rai_qt::settings::refresh_representative () } } -void rai_qt::settings::activate () +void nano_qt::settings::activate () { this->wallet.push_main_stack (window); } -void rai_qt::settings::update_locked (bool invalid, bool vulnerable) +void nano_qt::settings::update_locked (bool invalid, bool vulnerable) { if (invalid) { - this->wallet.active_status.insert (rai_qt::status_types::locked); + this->wallet.active_status.insert (nano_qt::status_types::locked); } else { - this->wallet.active_status.erase (rai_qt::status_types::locked); + this->wallet.active_status.erase (nano_qt::status_types::locked); } if (vulnerable) { - this->wallet.active_status.insert (rai_qt::status_types::vulnerable); + this->wallet.active_status.insert (nano_qt::status_types::vulnerable); } else { - this->wallet.active_status.erase (rai_qt::status_types::vulnerable); + this->wallet.active_status.erase (nano_qt::status_types::vulnerable); } } -rai_qt::advanced_actions::advanced_actions (rai_qt::wallet & wallet_a) : +nano_qt::advanced_actions::advanced_actions (nano_qt::wallet & wallet_a) : window (new QWidget), layout (new QVBoxLayout), show_ledger (new QPushButton ("Ledger")), @@ -1799,21 +1799,21 @@ wallet (wallet_a) if (mnano_unit->isChecked ()) { QSettings ().setValue (saved_ratio_key, ratio_group->id (mnano_unit)); - this->wallet.change_rendering_ratio (rai::Mxrb_ratio); + this->wallet.change_rendering_ratio (nano::Mxrb_ratio); } }); QObject::connect (knano_unit, &QRadioButton::toggled, [this]() { if (knano_unit->isChecked ()) { QSettings ().setValue (saved_ratio_key, ratio_group->id (knano_unit)); - this->wallet.change_rendering_ratio (rai::kxrb_ratio); + this->wallet.change_rendering_ratio (nano::kxrb_ratio); } }); QObject::connect (nano_unit, &QRadioButton::toggled, [this]() { if (nano_unit->isChecked ()) { QSettings ().setValue (saved_ratio_key, ratio_group->id (nano_unit)); - this->wallet.change_rendering_ratio (rai::xrb_ratio); + this->wallet.change_rendering_ratio (nano::xrb_ratio); } }); auto selected_ratio_id (QSettings ().value (saved_ratio_key, ratio_group->id (mnano_unit)).toInt ()); @@ -1846,8 +1846,8 @@ wallet (wallet_a) this->wallet.pop_main_stack (); }); QObject::connect (peers_bootstrap, &QPushButton::released, [this]() { - rai::endpoint endpoint; - auto error (rai::parse_endpoint (bootstrap_line->text ().toStdString (), endpoint)); + nano::endpoint endpoint; + auto error (nano::parse_endpoint (bootstrap_line->text ().toStdString (), endpoint)); if (!error) { show_line_ok (*bootstrap_line); @@ -1897,7 +1897,7 @@ wallet (wallet_a) enter_block->setToolTip ("Enter block in JSON format"); } -void rai_qt::advanced_actions::refresh_peers () +void nano_qt::advanced_actions::refresh_peers () { peers_model->removeRows (0, peers_model->rowCount ()); auto list (wallet.node.peers.list_version ()); @@ -1918,17 +1918,17 @@ void rai_qt::advanced_actions::refresh_peers () peer_count_label->setText (QString ("%1 peers").arg (peers_model->rowCount ())); } -void rai_qt::advanced_actions::refresh_ledger () +void nano_qt::advanced_actions::refresh_ledger () { ledger_model->removeRows (0, ledger_model->rowCount ()); auto transaction (wallet.node.store.tx_begin_read ()); for (auto i (wallet.node.ledger.store.latest_begin (transaction)), j (wallet.node.ledger.store.latest_end ()); i != j; ++i) { QList items; - items.push_back (new QStandardItem (QString (rai::block_hash (i->first).to_account ().c_str ()))); - rai::account_info info (i->second); + items.push_back (new QStandardItem (QString (nano::block_hash (i->first).to_account ().c_str ()))); + nano::account_info info (i->second); std::string balance; - rai::amount (info.balance.number () / wallet.rendering_ratio).encode_dec (balance); + nano::amount (info.balance.number () / wallet.rendering_ratio).encode_dec (balance); items.push_back (new QStandardItem (QString (balance.c_str ()))); std::string block_hash; info.head.encode_hex (block_hash); @@ -1937,12 +1937,12 @@ void rai_qt::advanced_actions::refresh_ledger () } } -void rai_qt::advanced_actions::refresh_stats () +void nano_qt::advanced_actions::refresh_stats () { wallet.stats_viewer.refresh_stats (); } -rai_qt::block_entry::block_entry (rai_qt::wallet & wallet_a) : +nano_qt::block_entry::block_entry (nano_qt::wallet & wallet_a) : window (new QWidget), layout (new QVBoxLayout), block (new QPlainTextEdit), @@ -1963,7 +1963,7 @@ wallet (wallet_a) boost::property_tree::ptree tree; std::stringstream istream (string); boost::property_tree::read_json (istream, tree); - auto block_l (rai::deserialize_block_json (tree)); + auto block_l (nano::deserialize_block_json (tree)); if (block_l != nullptr) { show_label_ok (*status); @@ -1987,7 +1987,7 @@ wallet (wallet_a) }); } -rai_qt::block_creation::block_creation (rai_qt::wallet & wallet_a) : +nano_qt::block_creation::block_creation (nano_qt::wallet & wallet_a) : window (new QWidget), layout (new QVBoxLayout), group (new QButtonGroup), @@ -2122,7 +2122,7 @@ wallet (wallet_a) send->click (); } -void rai_qt::block_creation::deactivate_all () +void nano_qt::block_creation::deactivate_all () { account_label->hide (); account->hide (); @@ -2136,7 +2136,7 @@ void rai_qt::block_creation::deactivate_all () representative->hide (); } -void rai_qt::block_creation::activate_send () +void nano_qt::block_creation::activate_send () { account_label->show (); account->show (); @@ -2146,13 +2146,13 @@ void rai_qt::block_creation::activate_send () destination->show (); } -void rai_qt::block_creation::activate_receive () +void nano_qt::block_creation::activate_receive () { source_label->show (); source->show (); } -void rai_qt::block_creation::activate_open () +void nano_qt::block_creation::activate_open () { source_label->show (); source->show (); @@ -2160,7 +2160,7 @@ void rai_qt::block_creation::activate_open () representative->show (); } -void rai_qt::block_creation::activate_change () +void nano_qt::block_creation::activate_change () { account_label->show (); account->show (); @@ -2168,33 +2168,33 @@ void rai_qt::block_creation::activate_change () representative->show (); } -void rai_qt::block_creation::create_send () +void nano_qt::block_creation::create_send () { - rai::account account_l; + nano::account account_l; auto error (account_l.decode_account (account->text ().toStdString ())); if (!error) { - rai::amount amount_l; + nano::amount amount_l; error = amount_l.decode_dec (amount->text ().toStdString ()); if (!error) { - rai::account destination_l; + nano::account destination_l; error = destination_l.decode_account (destination->text ().toStdString ()); if (!error) { auto transaction (wallet.node.store.tx_begin_read ()); - rai::raw_key key; + nano::raw_key key; if (!wallet.wallet_m->store.fetch (transaction, account_l, key)) { auto balance (wallet.node.ledger.account_balance (transaction, account_l)); if (amount_l.number () <= balance) { - rai::account_info info; + nano::account_info info; auto error (wallet.node.store.account_get (transaction, account_l, info)); assert (!error); auto rep_block (wallet.node.store.block_get (transaction, info.rep_block)); assert (rep_block != nullptr); - rai::state_block send (account_l, info.head, rep_block->representative (), balance - amount_l.number (), destination_l, key, account_l, 0); + nano::state_block send (account_l, info.head, rep_block->representative (), balance - amount_l.number (), destination_l, key, account_l, 0); wallet.node.work_generate_blocking (send); std::string block_l; send.serialize_json (block_l); @@ -2233,9 +2233,9 @@ void rai_qt::block_creation::create_send () } } -void rai_qt::block_creation::create_receive () +void nano_qt::block_creation::create_receive () { - rai::block_hash source_l; + nano::block_hash source_l; auto error (source_l.decode_hex (source->text ().toStdString ())); if (!error) { @@ -2246,21 +2246,21 @@ void rai_qt::block_creation::create_receive () auto destination (wallet.node.ledger.block_destination (transaction, *block_l)); if (!destination.is_zero ()) { - rai::pending_key pending_key (destination, source_l); - rai::pending_info pending; + nano::pending_key pending_key (destination, source_l); + nano::pending_info pending; if (!wallet.node.store.pending_get (transaction, pending_key, pending)) { - rai::account_info info; + nano::account_info info; auto error (wallet.node.store.account_get (transaction, pending_key.account, info)); if (!error) { - rai::raw_key key; + nano::raw_key key; auto error (wallet.wallet_m->store.fetch (transaction, pending_key.account, key)); if (!error) { auto rep_block (wallet.node.store.block_get (transaction, info.rep_block)); assert (rep_block != nullptr); - rai::state_block receive (pending_key.account, info.head, rep_block->representative (), info.balance.number () + pending.amount.number (), source_l, key, pending_key.account, 0); + nano::state_block receive (pending_key.account, info.head, rep_block->representative (), info.balance.number () + pending.amount.number (), source_l, key, pending_key.account, 0); wallet.node.work_generate_blocking (receive); std::string block_l; receive.serialize_json (block_l); @@ -2305,26 +2305,26 @@ void rai_qt::block_creation::create_receive () } } -void rai_qt::block_creation::create_change () +void nano_qt::block_creation::create_change () { - rai::account account_l; + nano::account account_l; auto error (account_l.decode_account (account->text ().toStdString ())); if (!error) { - rai::account representative_l; + nano::account representative_l; error = representative_l.decode_account (representative->text ().toStdString ()); if (!error) { auto transaction (wallet.node.store.tx_begin_read ()); - rai::account_info info; + nano::account_info info; auto error (wallet.node.store.account_get (transaction, account_l, info)); if (!error) { - rai::raw_key key; + nano::raw_key key; auto error (wallet.wallet_m->store.fetch (transaction, account_l, key)); if (!error) { - rai::state_block change (account_l, info.head, representative_l, info.balance, 0, key, account_l, 0); + nano::state_block change (account_l, info.head, representative_l, info.balance, 0, key, account_l, 0); wallet.node.work_generate_blocking (change); std::string block_l; change.serialize_json (block_l); @@ -2357,13 +2357,13 @@ void rai_qt::block_creation::create_change () } } -void rai_qt::block_creation::create_open () +void nano_qt::block_creation::create_open () { - rai::block_hash source_l; + nano::block_hash source_l; auto error (source_l.decode_hex (source->text ().toStdString ())); if (!error) { - rai::account representative_l; + nano::account representative_l; error = representative_l.decode_account (representative->text ().toStdString ()); if (!error) { @@ -2374,19 +2374,19 @@ void rai_qt::block_creation::create_open () auto destination (wallet.node.ledger.block_destination (transaction, *block_l)); if (!destination.is_zero ()) { - rai::pending_key pending_key (destination, source_l); - rai::pending_info pending; + nano::pending_key pending_key (destination, source_l); + nano::pending_info pending; if (!wallet.node.store.pending_get (transaction, pending_key, pending)) { - rai::account_info info; + nano::account_info info; auto error (wallet.node.store.account_get (transaction, pending_key.account, info)); if (error) { - rai::raw_key key; + nano::raw_key key; auto error (wallet.wallet_m->store.fetch (transaction, pending_key.account, key)); if (!error) { - rai::state_block open (pending_key.account, 0, representative_l, pending.amount, source_l, key, pending_key.account, 0); + nano::state_block open (pending_key.account, 0, representative_l, pending.amount, source_l, key, pending_key.account, 0); wallet.node.work_generate_blocking (open); std::string block_l; open.serialize_json (block_l); diff --git a/rai/qt/qt.hpp b/nano/qt/qt.hpp similarity index 74% rename from rai/qt/qt.hpp rename to nano/qt/qt.hpp index ebd51dcd..282ca653 100644 --- a/rai/qt/qt.hpp +++ b/nano/qt/qt.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include #include @@ -9,7 +9,7 @@ #include #include -namespace rai_qt +namespace nano_qt { static const QString saved_ratio_key = "settings/ratio"; class wallet; @@ -27,7 +27,7 @@ public: class settings { public: - settings (rai_qt::wallet &); + settings (nano_qt::wallet &); void refresh_representative (); void activate (); void update_locked (bool, bool); @@ -45,12 +45,12 @@ public: QLineEdit * new_representative; QPushButton * change_rep; QPushButton * back; - rai_qt::wallet & wallet; + nano_qt::wallet & wallet; }; class advanced_actions { public: - advanced_actions (rai_qt::wallet &); + advanced_actions (nano_qt::wallet &); QWidget * window; QVBoxLayout * layout; QPushButton * show_ledger; @@ -91,7 +91,7 @@ public: QPushButton * peers_refresh; QPushButton * peers_back; - rai_qt::wallet & wallet; + nano_qt::wallet & wallet; private: void refresh_ledger (); @@ -101,19 +101,19 @@ private: class block_entry { public: - block_entry (rai_qt::wallet &); + block_entry (nano_qt::wallet &); QWidget * window; QVBoxLayout * layout; QPlainTextEdit * block; QLabel * status; QPushButton * process; QPushButton * back; - rai_qt::wallet & wallet; + nano_qt::wallet & wallet; }; class block_creation { public: - block_creation (rai_qt::wallet &); + block_creation (nano_qt::wallet &); void deactivate_all (); void activate_send (); void activate_receive (); @@ -145,13 +145,13 @@ public: QLabel * status; QPushButton * create; QPushButton * back; - rai_qt::wallet & wallet; + nano_qt::wallet & wallet; }; class self_pane { public: - self_pane (rai_qt::wallet &, rai::account const &); - void set_balance_text (std::pair); + self_pane (nano_qt::wallet &, nano::account const &); + void set_balance_text (std::pair); QWidget * window; QVBoxLayout * layout; QHBoxLayout * self_layout; @@ -165,12 +165,12 @@ public: QWidget * balance_window; QHBoxLayout * balance_layout; QLabel * balance_label; - rai_qt::wallet & wallet; + nano_qt::wallet & wallet; }; class accounts { public: - accounts (rai_qt::wallet &); + accounts (nano_qt::wallet &); void refresh (); void refresh_wallet_balance (); QLabel * wallet_balance_label; @@ -186,12 +186,12 @@ public: QLineEdit * account_key_line; QPushButton * account_key_button; QPushButton * back; - rai_qt::wallet & wallet; + nano_qt::wallet & wallet; }; class import { public: - import (rai_qt::wallet &); + import (nano_qt::wallet &); QWidget * window; QVBoxLayout * layout; QLabel * seed_label; @@ -206,12 +206,12 @@ public: QLineEdit * password; QPushButton * perform; QPushButton * back; - rai_qt::wallet & wallet; + nano_qt::wallet & wallet; }; class history { public: - history (rai::ledger &, rai::account const &, rai_qt::wallet &); + history (nano::ledger &, nano::account const &, nano_qt::wallet &); void refresh (); QWidget * window; QVBoxLayout * layout; @@ -221,15 +221,15 @@ public: QHBoxLayout * tx_layout; QLabel * tx_label; QSpinBox * tx_count; - rai::ledger & ledger; - rai::account const & account; - rai_qt::wallet & wallet; + nano::ledger & ledger; + nano::account const & account; + nano_qt::wallet & wallet; }; class block_viewer { public: - block_viewer (rai_qt::wallet &); - void rebroadcast_action (rai::uint256_union const &); + block_viewer (nano_qt::wallet &); + void rebroadcast_action (nano::uint256_union const &); QWidget * window; QVBoxLayout * layout; QLabel * hash_label; @@ -241,12 +241,12 @@ public: QPushButton * retrieve; QPushButton * rebroadcast; QPushButton * back; - rai_qt::wallet & wallet; + nano_qt::wallet & wallet; }; class account_viewer { public: - account_viewer (rai_qt::wallet &); + account_viewer (nano_qt::wallet &); QWidget * window; QVBoxLayout * layout; QLabel * account_label; @@ -255,22 +255,22 @@ public: QWidget * balance_window; QHBoxLayout * balance_layout; QLabel * balance_label; - rai_qt::history history; + nano_qt::history history; QPushButton * back; - rai::account account; - rai_qt::wallet & wallet; + nano::account account; + nano_qt::wallet & wallet; }; class stats_viewer { public: - stats_viewer (rai_qt::wallet &); + stats_viewer (nano_qt::wallet &); QWidget * window; QVBoxLayout * layout; QPushButton * refresh; QStandardItemModel * model; QTableView * view; QPushButton * back; - rai_qt::wallet & wallet; + nano_qt::wallet & wallet; void refresh_stats (); }; enum class status_types @@ -287,41 +287,41 @@ enum class status_types class status { public: - status (rai_qt::wallet &); - void erase (rai_qt::status_types); - void insert (rai_qt::status_types); + status (nano_qt::wallet &); + void erase (nano_qt::status_types); + void insert (nano_qt::status_types); void set_text (); std::string text (); std::string color (); - std::set active; - rai_qt::wallet & wallet; + std::set active; + nano_qt::wallet & wallet; }; -class wallet : public std::enable_shared_from_this +class wallet : public std::enable_shared_from_this { public: - wallet (QApplication &, rai_qt::eventloop_processor &, rai::node &, std::shared_ptr, rai::account &); + wallet (QApplication &, nano_qt::eventloop_processor &, nano::node &, std::shared_ptr, nano::account &); void start (); void refresh (); void update_connected (); void empty_password (); - void change_rendering_ratio (rai::uint128_t const &); - std::string format_balance (rai::uint128_t const &) const; - rai::uint128_t rendering_ratio; - rai::node & node; - std::shared_ptr wallet_m; - rai::account & account; - rai_qt::eventloop_processor & processor; - rai_qt::history history; - rai_qt::accounts accounts; - rai_qt::self_pane self; - rai_qt::settings settings; - rai_qt::advanced_actions advanced; - rai_qt::block_creation block_creation; - rai_qt::block_entry block_entry; - rai_qt::block_viewer block_viewer; - rai_qt::account_viewer account_viewer; - rai_qt::stats_viewer stats_viewer; - rai_qt::import import; + void change_rendering_ratio (nano::uint128_t const &); + std::string format_balance (nano::uint128_t const &) const; + nano::uint128_t rendering_ratio; + nano::node & node; + std::shared_ptr wallet_m; + nano::account & account; + nano_qt::eventloop_processor & processor; + nano_qt::history history; + nano_qt::accounts accounts; + nano_qt::self_pane self; + nano_qt::settings settings; + nano_qt::advanced_actions advanced; + nano_qt::block_creation block_creation; + nano_qt::block_entry block_entry; + nano_qt::block_viewer block_viewer; + nano_qt::account_viewer account_viewer; + nano_qt::stats_viewer stats_viewer; + nano_qt::import import; QApplication & application; QLabel * status; @@ -348,7 +348,7 @@ public: QPushButton * send_blocks_send; QPushButton * send_blocks_back; - rai_qt::status active_status; + nano_qt::status active_status; void pop_main_stack (); void push_main_stack (QWidget *); void ongoing_refresh (); diff --git a/rai/qt_system/entry.cpp b/nano/qt_system/entry.cpp similarity index 60% rename from rai/qt_system/entry.cpp rename to nano/qt_system/entry.cpp index 5cc7fc0a..442dab49 100644 --- a/rai/qt_system/entry.cpp +++ b/nano/qt_system/entry.cpp @@ -1,5 +1,5 @@ -#include -#include +#include +#include #include @@ -9,23 +9,23 @@ int main (int argc, char ** argv) QCoreApplication::setOrganizationName ("Nano"); QCoreApplication::setOrganizationDomain ("nano.org"); QCoreApplication::setApplicationName ("Nano Wallet"); - rai_qt::eventloop_processor processor; + nano_qt::eventloop_processor processor; static int count (16); - rai::system system (24000, count); + nano::system system (24000, count); std::unique_ptr client_tabs (new QTabWidget); - std::vector> guis; + std::vector> guis; for (auto i (0); i < count; ++i) { - rai::uint256_union wallet_id; - rai::random_pool.GenerateBlock (wallet_id.bytes.data (), wallet_id.bytes.size ()); + nano::uint256_union wallet_id; + nano::random_pool.GenerateBlock (wallet_id.bytes.data (), wallet_id.bytes.size ()); auto wallet (system.nodes[i]->wallets.create (wallet_id)); - rai::keypair key; + nano::keypair key; wallet->insert_adhoc (key.prv); - guis.push_back (std::unique_ptr (new rai_qt::wallet (application, processor, *system.nodes[i], wallet, key.pub))); + guis.push_back (std::unique_ptr (new nano_qt::wallet (application, processor, *system.nodes[i], wallet, key.pub))); client_tabs->addTab (guis.back ()->client_window, boost::str (boost::format ("Wallet %1%") % i).c_str ()); } client_tabs->show (); - rai::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); + nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); QObject::connect (&application, &QApplication::aboutToQuit, [&]() { system.stop (); }); diff --git a/rai/qt_test/entry.cpp b/nano/qt_test/entry.cpp similarity index 100% rename from rai/qt_test/entry.cpp rename to nano/qt_test/entry.cpp diff --git a/rai/qt_test/qt.cpp b/nano/qt_test/qt.cpp similarity index 66% rename from rai/qt_test/qt.cpp rename to nano/qt_test/qt.cpp index 656c63ef..ed1733f9 100644 --- a/rai/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -2,10 +2,10 @@ #include -#include -#include +#include +#include -#include +#include #include @@ -18,11 +18,11 @@ extern QApplication * test_application; TEST (wallet, construction) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 1); - auto wallet_l (system.nodes[0]->wallets.create (rai::uint256_union ())); + nano_qt::eventloop_processor processor; + nano::system system (24000, 1); + auto wallet_l (system.nodes[0]->wallets.create (nano::uint256_union ())); auto key (wallet_l->deterministic_insert ()); - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], wallet_l, key)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], wallet_l, key)); wallet->start (); std::string account (key.to_account ()); ASSERT_EQ (account, wallet->self.account_text->text ().toStdString ()); @@ -33,55 +33,55 @@ TEST (wallet, construction) TEST (wallet, status) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 1); - auto wallet_l (system.nodes[0]->wallets.create (rai::uint256_union ())); - rai::keypair key; + nano_qt::eventloop_processor processor; + nano::system system (24000, 1); + auto wallet_l (system.nodes[0]->wallets.create (nano::uint256_union ())); + nano::keypair key; wallet_l->insert_adhoc (key.prv); - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], wallet_l, key.pub)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], wallet_l, key.pub)); wallet->start (); - auto wallet_has = [wallet](rai_qt::status_types status_ty) { + auto wallet_has = [wallet](nano_qt::status_types status_ty) { return wallet->active_status.active.find (status_ty) != wallet->active_status.active.end (); }; ASSERT_EQ ("Status: Disconnected, Block: 1", wallet->status->text ().toStdString ()); - system.nodes[0]->peers.insert (rai::endpoint (boost::asio::ip::address_v6::loopback (), 10000), 0); + system.nodes[0]->peers.insert (nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000), 0); // Because of the wallet "vulnerable" message, this won't be the message displayed. // However, it will still be part of the status set. - ASSERT_FALSE (wallet_has (rai_qt::status_types::synchronizing)); + ASSERT_FALSE (wallet_has (nano_qt::status_types::synchronizing)); system.deadline_set (25s); - while (!wallet_has (rai_qt::status_types::synchronizing)) + while (!wallet_has (nano_qt::status_types::synchronizing)) { test_application->processEvents (); ASSERT_NO_ERROR (system.poll ()); } system.nodes[0]->peers.purge_list (std::chrono::steady_clock::now () + std::chrono::seconds (5)); - while (wallet_has (rai_qt::status_types::synchronizing)) + while (wallet_has (nano_qt::status_types::synchronizing)) { test_application->processEvents (); } - ASSERT_TRUE (wallet_has (rai_qt::status_types::disconnected)); + ASSERT_TRUE (wallet_has (nano_qt::status_types::disconnected)); } TEST (wallet, startup_balance) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 1); - auto wallet_l (system.nodes[0]->wallets.create (rai::uint256_union ())); - rai::keypair key; + nano_qt::eventloop_processor processor; + nano::system system (24000, 1); + auto wallet_l (system.nodes[0]->wallets.create (nano::uint256_union ())); + nano::keypair key; wallet_l->insert_adhoc (key.prv); - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], wallet_l, key.pub)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], wallet_l, key.pub)); wallet->start (); ASSERT_EQ ("Balance: 0 NANO", wallet->self.balance_label->text ().toStdString ()); } TEST (wallet, select_account) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 1); - auto wallet_l (system.nodes[0]->wallets.create (rai::uint256_union ())); - rai::public_key key1 (wallet_l->deterministic_insert ()); - rai::public_key key2 (wallet_l->deterministic_insert ()); - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], wallet_l, key1)); + nano_qt::eventloop_processor processor; + nano::system system (24000, 1); + auto wallet_l (system.nodes[0]->wallets.create (nano::uint256_union ())); + nano::public_key key1 (wallet_l->deterministic_insert ()); + nano::public_key key2 (wallet_l->deterministic_insert ()); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], wallet_l, key1)); wallet->start (); ASSERT_EQ (key1, wallet->account); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); @@ -98,12 +98,12 @@ TEST (wallet, select_account) TEST (wallet, main) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 1); - auto wallet_l (system.nodes[0]->wallets.create (rai::uint256_union ())); - rai::keypair key; + nano_qt::eventloop_processor processor; + nano::system system (24000, 1); + auto wallet_l (system.nodes[0]->wallets.create (nano::uint256_union ())); + nano::keypair key; wallet_l->insert_adhoc (key.prv); - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], wallet_l, key.pub)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], wallet_l, key.pub)); wallet->start (); ASSERT_EQ (wallet->entry_window, wallet->main_stack->currentWidget ()); QTest::mouseClick (wallet->send_blocks, Qt::LeftButton); @@ -129,21 +129,21 @@ TEST (wallet, main) TEST (wallet, password_change) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 1); - rai::account account; - system.wallet (0)->insert_adhoc (rai::keypair ().prv); + nano_qt::eventloop_processor processor; + nano::system system (24000, 1); + nano::account account; + system.wallet (0)->insert_adhoc (nano::keypair ().prv); { auto transaction (system.nodes[0]->store.tx_begin ()); account = system.account (transaction, 0); } - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); QTest::mouseClick (wallet->settings_button, Qt::LeftButton); { auto transaction (system.nodes[0]->store.tx_begin ()); - rai::raw_key password1; - rai::raw_key password2; + nano::raw_key password1; + nano::raw_key password2; system.wallet (0)->store.derive_key (password1, transaction, "1"); system.wallet (0)->store.password.value (password2); ASSERT_NE (password1, password2); @@ -153,8 +153,8 @@ TEST (wallet, password_change) QTest::mouseClick (wallet->settings.change, Qt::LeftButton); { auto transaction (system.nodes[0]->store.tx_begin ()); - rai::raw_key password1; - rai::raw_key password2; + nano::raw_key password1; + nano::raw_key password2; system.wallet (0)->store.derive_key (password1, transaction, "1"); system.wallet (0)->store.password.value (password2); ASSERT_EQ (password1, password2); @@ -165,18 +165,18 @@ TEST (wallet, password_change) TEST (client, password_nochange) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 1); - rai::account account; - system.wallet (0)->insert_adhoc (rai::keypair ().prv); + nano_qt::eventloop_processor processor; + nano::system system (24000, 1); + nano::account account; + system.wallet (0)->insert_adhoc (nano::keypair ().prv); { auto transaction (system.nodes[0]->store.tx_begin ()); account = system.account (transaction, 0); } - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); QTest::mouseClick (wallet->settings_button, Qt::LeftButton); - rai::raw_key password; + nano::raw_key password; password.data.clear (); system.deadline_set (10s); while (password.data == 0) @@ -186,9 +186,9 @@ TEST (client, password_nochange) } { auto transaction (system.nodes[0]->store.tx_begin ()); - rai::raw_key password1; + nano::raw_key password1; system.wallet (0)->store.derive_key (password1, transaction, ""); - rai::raw_key password2; + nano::raw_key password2; system.wallet (0)->store.password.value (password2); ASSERT_EQ (password1, password2); } @@ -197,9 +197,9 @@ TEST (client, password_nochange) QTest::mouseClick (wallet->settings.change, Qt::LeftButton); { auto transaction (system.nodes[0]->store.tx_begin ()); - rai::raw_key password1; + nano::raw_key password1; system.wallet (0)->store.derive_key (password1, transaction, ""); - rai::raw_key password2; + nano::raw_key password2; system.wallet (0)->store.password.value (password2); ASSERT_EQ (password1, password2); } @@ -209,15 +209,15 @@ TEST (client, password_nochange) TEST (wallet, enter_password) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 2); - rai::account account; - system.wallet (0)->insert_adhoc (rai::keypair ().prv); + nano_qt::eventloop_processor processor; + nano::system system (24000, 2); + nano::account account; + system.wallet (0)->insert_adhoc (nano::keypair ().prv); { auto transaction (system.nodes[0]->store.tx_begin ()); account = system.account (transaction, 0); } - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); ASSERT_NE (-1, wallet->settings.layout->indexOf (wallet->settings.password)); ASSERT_NE (-1, wallet->settings.layout->indexOf (wallet->settings.lock_toggle)); @@ -246,12 +246,12 @@ TEST (wallet, enter_password) TEST (wallet, send) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 2); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::public_key key1 (system.wallet (1)->insert_adhoc (rai::keypair ().prv)); - auto account (rai::test_genesis_key.pub); - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); + nano_qt::eventloop_processor processor; + nano::system system (24000, 2); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::public_key key1 (system.wallet (1)->insert_adhoc (nano::keypair ().prv)); + auto account (nano::test_genesis_key.pub); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); QTest::mouseClick (wallet->send_blocks, Qt::LeftButton); QTest::keyClicks (wallet->send_account, key1.to_account ().c_str ()); @@ -262,7 +262,7 @@ TEST (wallet, send) { ASSERT_NO_ERROR (system.poll ()); } - rai::uint128_t amount (wallet->node.balance (key1)); + nano::uint128_t amount (wallet->node.balance (key1)); ASSERT_EQ (2 * wallet->rendering_ratio, amount); QTest::mouseClick (wallet->send_blocks_back, Qt::LeftButton); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); @@ -278,16 +278,16 @@ TEST (wallet, send) TEST (wallet, send_locked) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key1; + nano_qt::eventloop_processor processor; + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key1; { auto transaction (system.wallet (0)->wallets.tx_begin (true)); system.wallet (0)->enter_password (transaction, "0"); } - auto account (rai::test_genesis_key.pub); - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); + auto account (nano::test_genesis_key.pub); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); QTest::mouseClick (wallet->send_blocks, Qt::LeftButton); QTest::keyClicks (wallet->send_account, key1.pub.to_account ().c_str ()); @@ -303,25 +303,25 @@ TEST (wallet, send_locked) TEST (wallet, process_block) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 1); - rai::account account; - rai::block_hash latest (system.nodes[0]->latest (rai::genesis_account)); - system.wallet (0)->insert_adhoc (rai::keypair ().prv); + nano_qt::eventloop_processor processor; + nano::system system (24000, 1); + nano::account account; + nano::block_hash latest (system.nodes[0]->latest (nano::genesis_account)); + system.wallet (0)->insert_adhoc (nano::keypair ().prv); { auto transaction (system.nodes[0]->store.tx_begin ()); account = system.account (transaction, 0); } - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); ASSERT_EQ ("Process", wallet->block_entry.process->text ()); ASSERT_EQ ("Back", wallet->block_entry.back->text ()); - rai::keypair key1; + nano::keypair key1; ASSERT_EQ (wallet->entry_window, wallet->main_stack->currentWidget ()); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); QTest::mouseClick (wallet->advanced.enter_block, Qt::LeftButton); ASSERT_EQ (wallet->block_entry.window, wallet->main_stack->currentWidget ()); - rai::send_block send (latest, key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (latest)); + nano::send_block send (latest, key1.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (latest)); std::string previous; send.hashables.previous.encode_hex (previous); std::string balance; @@ -347,19 +347,19 @@ TEST (wallet, process_block) TEST (wallet, create_send) { - rai_qt::eventloop_processor processor; - rai::keypair key; - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano_qt::eventloop_processor processor; + nano::keypair key; + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - auto account (rai::test_genesis_key.pub); - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); + auto account (nano::test_genesis_key.pub); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); wallet->client_window->show (); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); QTest::mouseClick (wallet->advanced.create_block, Qt::LeftButton); QTest::mouseClick (wallet->block_creation.send, Qt::LeftButton); - QTest::keyClicks (wallet->block_creation.account, rai::test_genesis_key.pub.to_account ().c_str ()); + QTest::keyClicks (wallet->block_creation.account, nano::test_genesis_key.pub.to_account ().c_str ()); QTest::keyClicks (wallet->block_creation.amount, "100000000000000000000"); QTest::keyClicks (wallet->block_creation.destination, key.pub.to_account ().c_str ()); QTest::mouseClick (wallet->block_creation.create, Qt::LeftButton); @@ -369,33 +369,33 @@ TEST (wallet, create_send) std::stringstream istream (json); boost::property_tree::read_json (istream, tree1); bool error (false); - rai::state_block send (error, tree1); + nano::state_block send (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (send).code); - ASSERT_EQ (rai::process_result::old, system.nodes[0]->process (send).code); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (send).code); + ASSERT_EQ (nano::process_result::old, system.nodes[0]->process (send).code); } TEST (wallet, create_open_receive) { - rai_qt::eventloop_processor processor; - rai::keypair key; - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - system.wallet (0)->send_action (rai::test_genesis_key.pub, key.pub, 100); - rai::block_hash latest1 (system.nodes[0]->latest (rai::test_genesis_key.pub)); - system.wallet (0)->send_action (rai::test_genesis_key.pub, key.pub, 100); - rai::block_hash latest2 (system.nodes[0]->latest (rai::test_genesis_key.pub)); + nano_qt::eventloop_processor processor; + nano::keypair key; + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + system.wallet (0)->send_action (nano::test_genesis_key.pub, key.pub, 100); + nano::block_hash latest1 (system.nodes[0]->latest (nano::test_genesis_key.pub)); + system.wallet (0)->send_action (nano::test_genesis_key.pub, key.pub, 100); + nano::block_hash latest2 (system.nodes[0]->latest (nano::test_genesis_key.pub)); ASSERT_NE (latest1, latest2); system.wallet (0)->insert_adhoc (key.prv); - auto account (rai::test_genesis_key.pub); - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); + auto account (nano::test_genesis_key.pub); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); wallet->client_window->show (); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); QTest::mouseClick (wallet->advanced.create_block, Qt::LeftButton); wallet->block_creation.open->click (); QTest::keyClicks (wallet->block_creation.source, latest1.to_string ().c_str ()); - QTest::keyClicks (wallet->block_creation.representative, rai::test_genesis_key.pub.to_account ().c_str ()); + QTest::keyClicks (wallet->block_creation.representative, nano::test_genesis_key.pub.to_account ().c_str ()); QTest::mouseClick (wallet->block_creation.create, Qt::LeftButton); std::string json1 (wallet->block_creation.block->toPlainText ().toStdString ()); ASSERT_FALSE (json1.empty ()); @@ -403,10 +403,10 @@ TEST (wallet, create_open_receive) std::stringstream istream1 (json1); boost::property_tree::read_json (istream1, tree1); bool error (false); - rai::state_block open (error, tree1); + nano::state_block open (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (open).code); - ASSERT_EQ (rai::process_result::old, system.nodes[0]->process (open).code); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code); + ASSERT_EQ (nano::process_result::old, system.nodes[0]->process (open).code); wallet->block_creation.block->clear (); wallet->block_creation.source->clear (); QTest::mouseClick (wallet->block_creation.receive, Qt::LeftButton); @@ -418,26 +418,26 @@ TEST (wallet, create_open_receive) std::stringstream istream2 (json2); boost::property_tree::read_json (istream2, tree2); bool error2 (false); - rai::state_block receive (error2, tree2); + nano::state_block receive (error2, tree2); ASSERT_FALSE (error2); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (receive).code); - ASSERT_EQ (rai::process_result::old, system.nodes[0]->process (receive).code); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (receive).code); + ASSERT_EQ (nano::process_result::old, system.nodes[0]->process (receive).code); } TEST (wallet, create_change) { - rai_qt::eventloop_processor processor; - rai::keypair key; - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto account (rai::test_genesis_key.pub); - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); + nano_qt::eventloop_processor processor; + nano::keypair key; + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto account (nano::test_genesis_key.pub); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); wallet->client_window->show (); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); QTest::mouseClick (wallet->advanced.create_block, Qt::LeftButton); QTest::mouseClick (wallet->block_creation.change, Qt::LeftButton); - QTest::keyClicks (wallet->block_creation.account, rai::test_genesis_key.pub.to_account ().c_str ()); + QTest::keyClicks (wallet->block_creation.account, nano::test_genesis_key.pub.to_account ().c_str ()); QTest::keyClicks (wallet->block_creation.representative, key.pub.to_account ().c_str ()); QTest::mouseClick (wallet->block_creation.create, Qt::LeftButton); std::string json (wallet->block_creation.block->toPlainText ().toStdString ()); @@ -446,63 +446,63 @@ TEST (wallet, create_change) std::stringstream istream (json); boost::property_tree::read_json (istream, tree1); bool error (false); - rai::state_block change (error, tree1); + nano::state_block change (error, tree1); ASSERT_FALSE (error); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (change).code); - ASSERT_EQ (rai::process_result::old, system.nodes[0]->process (change).code); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (change).code); + ASSERT_EQ (nano::process_result::old, system.nodes[0]->process (change).code); } TEST (history, short_text) { bool init (false); - rai_qt::eventloop_processor processor; - rai::keypair key; - rai::system system (24000, 1); + nano_qt::eventloop_processor processor; + nano::keypair key; + nano::system system (24000, 1); system.wallet (0)->insert_adhoc (key.prv); - rai::account account; + nano::account account; { auto transaction (system.nodes[0]->store.tx_begin ()); account = system.account (transaction, 0); } - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); - rai::mdb_store store (init, rai::unique_path ()); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_TRUE (!init); - rai::genesis genesis; - rai::ledger ledger (store, system.nodes[0]->stats); + nano::genesis genesis; + nano::ledger ledger (store, system.nodes[0]->stats); { auto transaction (store.tx_begin (true)); store.initialize (transaction, genesis); - rai::keypair key; - rai::send_block send (ledger.latest (transaction, rai::test_genesis_key.pub), rai::test_genesis_key.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send).code); - rai::receive_block receive (send.hash (), send.hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, receive).code); - rai::change_block change (receive.hash (), key.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, change).code); + nano::keypair key; + nano::send_block send (ledger.latest (transaction, nano::test_genesis_key.pub), nano::test_genesis_key.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); + nano::receive_block receive (send.hash (), send.hash (), nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code); + nano::change_block change (receive.hash (), key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change).code); } - rai_qt::history history (ledger, rai::test_genesis_key.pub, *wallet); + nano_qt::history history (ledger, nano::test_genesis_key.pub, *wallet); history.refresh (); ASSERT_EQ (4, history.model->rowCount ()); } TEST (wallet, startup_work) { - rai_qt::eventloop_processor processor; - rai::keypair key; - rai::system system (24000, 1); + nano_qt::eventloop_processor processor; + nano::keypair key; + nano::system system (24000, 1); system.wallet (0)->insert_adhoc (key.prv); - rai::account account; + nano::account account; { auto transaction (system.nodes[0]->store.tx_begin ()); account = system.account (transaction, 0); } - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); uint64_t work1; { auto transaction (system.nodes[0]->store.tx_begin ()); - ASSERT_TRUE (wallet->wallet_m->store.work_get (transaction, rai::test_genesis_key.pub, work1)); + ASSERT_TRUE (wallet->wallet_m->store.work_get (transaction, nano::test_genesis_key.pub, work1)); } QTest::mouseClick (wallet->accounts_button, Qt::LeftButton); QTest::keyClicks (wallet->accounts.account_key_line, "34F0A37AAD20F4A260F0A5B3CB3D7FB50673212263E58A380BC10474BB039CE4"); @@ -513,28 +513,28 @@ TEST (wallet, startup_work) { ASSERT_NO_ERROR (system.poll ()); auto transaction (system.nodes[0]->store.tx_begin ()); - again = wallet->wallet_m->store.work_get (transaction, rai::test_genesis_key.pub, work1); + again = wallet->wallet_m->store.work_get (transaction, nano::test_genesis_key.pub, work1); } } TEST (wallet, block_viewer) { - rai_qt::eventloop_processor processor; - rai::keypair key; - rai::system system (24000, 1); + nano_qt::eventloop_processor processor; + nano::keypair key; + nano::system system (24000, 1); system.wallet (0)->insert_adhoc (key.prv); - rai::account account; + nano::account account; { auto transaction (system.nodes[0]->store.tx_begin ()); account = system.account (transaction, 0); } - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); ASSERT_NE (-1, wallet->advanced.layout->indexOf (wallet->advanced.block_viewer)); QTest::mouseClick (wallet->advanced.block_viewer, Qt::LeftButton); ASSERT_EQ (wallet->block_viewer.window, wallet->main_stack->currentWidget ()); - rai::block_hash latest (system.nodes[0]->latest (rai::genesis_account)); + nano::block_hash latest (system.nodes[0]->latest (nano::genesis_account)); QTest::keyClicks (wallet->block_viewer.hash, latest.to_string ().c_str ()); QTest::mouseClick (wallet->block_viewer.retrieve, Qt::LeftButton); ASSERT_FALSE (wallet->block_viewer.block->toPlainText ().toStdString ().empty ()); @@ -544,24 +544,24 @@ TEST (wallet, block_viewer) TEST (wallet, import) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 2); + nano_qt::eventloop_processor processor; + nano::system system (24000, 2); std::string json; - rai::keypair key1; - rai::keypair key2; + nano::keypair key1; + nano::keypair key2; system.wallet (0)->insert_adhoc (key1.prv); { auto transaction (system.nodes[0]->store.tx_begin ()); system.wallet (0)->store.serialize_json (transaction, json); } system.wallet (1)->insert_adhoc (key2.prv); - auto path (rai::unique_path ()); + auto path (nano::unique_path ()); { std::ofstream stream; stream.open (path.string ().c_str ()); stream << json; } - auto wallet (std::make_shared (*test_application, processor, *system.nodes[1], system.wallet (1), key2.pub)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[1], system.wallet (1), key2.pub)); wallet->start (); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); ASSERT_EQ (wallet->advanced.window, wallet->main_stack->currentWidget ()); @@ -578,19 +578,19 @@ TEST (wallet, import) TEST (wallet, republish) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 2); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key; - rai::block_hash hash; + nano_qt::eventloop_processor processor; + nano::system system (24000, 2); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::keypair key; + nano::block_hash hash; { auto transaction (system.nodes[0]->store.tx_begin (true)); - rai::send_block block (system.nodes[0]->ledger.latest (transaction, rai::test_genesis_key.pub), key.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); + nano::send_block block (system.nodes[0]->ledger.latest (transaction, nano::test_genesis_key.pub), key.pub, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); hash = block.hash (); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->ledger.process (transaction, block).code); + ASSERT_EQ (nano::process_result::progress, system.nodes[0]->ledger.process (transaction, block).code); } - auto account (rai::test_genesis_key.pub); - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); + auto account (nano::test_genesis_key.pub); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); ASSERT_EQ (wallet->advanced.window, wallet->main_stack->currentWidget ()); @@ -598,9 +598,9 @@ TEST (wallet, republish) ASSERT_EQ (wallet->block_viewer.window, wallet->main_stack->currentWidget ()); QTest::keyClicks (wallet->block_viewer.hash, hash.to_string ().c_str ()); QTest::mouseClick (wallet->block_viewer.rebroadcast, Qt::LeftButton); - ASSERT_FALSE (system.nodes[1]->balance (rai::test_genesis_key.pub).is_zero ()); + ASSERT_FALSE (system.nodes[1]->balance (nano::test_genesis_key.pub).is_zero ()); system.deadline_set (10s); - while (system.nodes[1]->balance (rai::test_genesis_key.pub).is_zero ()) + while (system.nodes[1]->balance (nano::test_genesis_key.pub).is_zero ()) { ASSERT_NO_ERROR (system.poll ()); } @@ -608,21 +608,21 @@ TEST (wallet, republish) TEST (wallet, ignore_empty_adhoc) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 1); - rai::keypair key1; + nano_qt::eventloop_processor processor; + nano::system system (24000, 1); + nano::keypair key1; system.wallet (0)->insert_adhoc (key1.prv); - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), key1.pub)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), key1.pub)); wallet->start (); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); ASSERT_EQ (wallet->advanced.window, wallet->main_stack->currentWidget ()); QTest::mouseClick (wallet->accounts_button, Qt::LeftButton); ASSERT_EQ (wallet->accounts.window, wallet->main_stack->currentWidget ()); - QTest::keyClicks (wallet->accounts.account_key_line, rai::test_genesis_key.prv.data.to_string ().c_str ()); + QTest::keyClicks (wallet->accounts.account_key_line, nano::test_genesis_key.prv.data.to_string ().c_str ()); QTest::mouseClick (wallet->accounts.account_key_button, Qt::LeftButton); ASSERT_EQ (1, wallet->accounts.model->rowCount ()); ASSERT_EQ (0, wallet->accounts.account_key_line->text ().length ()); - rai::keypair key; + nano::keypair key; QTest::keyClicks (wallet->accounts.account_key_line, key.prv.data.to_string ().c_str ()); QTest::mouseClick (wallet->accounts.account_key_button, Qt::LeftButton); ASSERT_EQ (1, wallet->accounts.model->rowCount ()); @@ -635,17 +635,17 @@ TEST (wallet, ignore_empty_adhoc) TEST (wallet, change_seed) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 1); + nano_qt::eventloop_processor processor; + nano::system system (24000, 1); auto key1 (system.wallet (0)->deterministic_insert ()); system.wallet (0)->deterministic_insert (); - rai::raw_key seed3; + nano::raw_key seed3; { auto transaction (system.wallet (0)->wallets.tx_begin ()); system.wallet (0)->store.seed (seed3, transaction); } auto wallet_key (key1); - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), wallet_key)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), wallet_key)); wallet->start (); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); ASSERT_EQ (wallet->advanced.window, wallet->main_stack->currentWidget ()); @@ -653,10 +653,10 @@ TEST (wallet, change_seed) ASSERT_EQ (wallet->accounts.window, wallet->main_stack->currentWidget ()); QTest::mouseClick (wallet->accounts.import_wallet, Qt::LeftButton); ASSERT_EQ (wallet->import.window, wallet->main_stack->currentWidget ()); - rai::raw_key seed; + nano::raw_key seed; seed.data.clear (); QTest::keyClicks (wallet->import.seed, seed.data.to_string ().c_str ()); - rai::raw_key seed1; + nano::raw_key seed1; { auto transaction (system.wallet (0)->wallets.tx_begin ()); system.wallet (0)->store.seed (seed1, transaction); @@ -670,7 +670,7 @@ TEST (wallet, change_seed) QTest::mouseClick (wallet->import.import_seed, Qt::LeftButton); ASSERT_EQ (1, wallet->accounts.model->rowCount ()); ASSERT_TRUE (wallet->import.clear_line->text ().toStdString ().empty ()); - rai::raw_key seed2; + nano::raw_key seed2; auto transaction (system.wallet (0)->wallets.tx_begin ()); system.wallet (0)->store.seed (seed2, transaction); ASSERT_EQ (seed, seed2); @@ -688,10 +688,10 @@ TEST (wallet, change_seed) TEST (wallet, seed_work_generation) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 1); + nano_qt::eventloop_processor processor; + nano::system system (24000, 1); auto key1 (system.wallet (0)->deterministic_insert ()); - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), key1)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), key1)); wallet->start (); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); ASSERT_EQ (wallet->advanced.window, wallet->main_stack->currentWidget ()); @@ -699,7 +699,7 @@ TEST (wallet, seed_work_generation) ASSERT_EQ (wallet->accounts.window, wallet->main_stack->currentWidget ()); QTest::mouseClick (wallet->accounts.import_wallet, Qt::LeftButton); ASSERT_EQ (wallet->import.window, wallet->main_stack->currentWidget ()); - rai::raw_key seed; + nano::raw_key seed; seed.data.clear (); QTest::keyClicks (wallet->import.seed, seed.data.to_string ().c_str ()); QTest::keyClicks (wallet->import.clear_line, "clear keys"); @@ -719,22 +719,22 @@ TEST (wallet, seed_work_generation) ASSERT_NO_ERROR (ec); } auto transaction (system.wallet (0)->wallets.tx_begin ()); - ASSERT_FALSE (rai::work_validate (system.nodes[0]->ledger.latest_root (transaction, key1), work)); + ASSERT_FALSE (nano::work_validate (system.nodes[0]->ledger.latest_root (transaction, key1), work)); } TEST (wallet, backup_seed) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 1); + nano_qt::eventloop_processor processor; + nano::system system (24000, 1); auto key1 (system.wallet (0)->deterministic_insert ()); - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), key1)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), key1)); wallet->start (); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); ASSERT_EQ (wallet->advanced.window, wallet->main_stack->currentWidget ()); QTest::mouseClick (wallet->accounts_button, Qt::LeftButton); ASSERT_EQ (wallet->accounts.window, wallet->main_stack->currentWidget ()); QTest::mouseClick (wallet->accounts.backup_seed, Qt::LeftButton); - rai::raw_key seed; + nano::raw_key seed; auto transaction (system.wallet (0)->wallets.tx_begin ()); system.wallet (0)->store.seed (seed, transaction); ASSERT_EQ (seed.data.to_string (), test_application->clipboard ()->text ().toStdString ()); @@ -742,20 +742,20 @@ TEST (wallet, backup_seed) TEST (wallet, import_locked) { - rai_qt::eventloop_processor processor; - rai::system system (24000, 1); + nano_qt::eventloop_processor processor; + nano::system system (24000, 1); auto key1 (system.wallet (0)->deterministic_insert ()); { auto transaction (system.wallet (0)->wallets.tx_begin (true)); system.wallet (0)->store.rekey (transaction, "1"); } - auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), key1)); + auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), key1)); wallet->start (); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); ASSERT_EQ (wallet->advanced.window, wallet->main_stack->currentWidget ()); QTest::mouseClick (wallet->accounts_button, Qt::LeftButton); ASSERT_EQ (wallet->accounts.window, wallet->main_stack->currentWidget ()); - rai::raw_key seed1; + nano::raw_key seed1; seed1.data.clear (); QTest::keyClicks (wallet->import.seed, seed1.data.to_string ().c_str ()); QTest::keyClicks (wallet->import.clear_line, "clear keys"); @@ -764,7 +764,7 @@ TEST (wallet, import_locked) system.wallet (0)->enter_password (transaction, ""); } QTest::mouseClick (wallet->import.import_seed, Qt::LeftButton); - rai::raw_key seed2; + nano::raw_key seed2; { auto transaction (system.wallet (0)->wallets.tx_begin (true)); system.wallet (0)->store.seed (seed2, transaction); @@ -772,7 +772,7 @@ TEST (wallet, import_locked) system.wallet (0)->enter_password (transaction, "1"); } QTest::mouseClick (wallet->import.import_seed, Qt::LeftButton); - rai::raw_key seed3; + nano::raw_key seed3; auto transaction (system.wallet (0)->wallets.tx_begin ()); system.wallet (0)->store.seed (seed3, transaction); ASSERT_EQ (seed1, seed3); @@ -780,29 +780,29 @@ TEST (wallet, import_locked) // DISABLED: this always fails TEST (wallet, DISABLED_synchronizing) { - rai_qt::eventloop_processor processor; - rai::system system0 (24000, 1); - rai::system system1 (24001, 1); + nano_qt::eventloop_processor processor; + nano::system system0 (24000, 1); + nano::system system1 (24001, 1); auto key1 (system0.wallet (0)->deterministic_insert ()); - auto wallet (std::make_shared (*test_application, processor, *system0.nodes[0], system0.wallet (0), key1)); + auto wallet (std::make_shared (*test_application, processor, *system0.nodes[0], system0.wallet (0), key1)); wallet->start (); { auto transaction (system1.nodes[0]->store.tx_begin (true)); - auto latest (system1.nodes[0]->ledger.latest (transaction, rai::genesis_account)); - rai::send_block send (latest, key1, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system1.work.generate (latest)); + auto latest (system1.nodes[0]->ledger.latest (transaction, nano::genesis_account)); + nano::send_block send (latest, key1, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system1.work.generate (latest)); system1.nodes[0]->ledger.process (transaction, send); } - ASSERT_EQ (0, wallet->active_status.active.count (rai_qt::status_types::synchronizing)); + ASSERT_EQ (0, wallet->active_status.active.count (nano_qt::status_types::synchronizing)); system0.nodes[0]->bootstrap_initiator.bootstrap (system1.nodes[0]->network.endpoint ()); system1.deadline_set (10s); - while (wallet->active_status.active.count (rai_qt::status_types::synchronizing) == 0) + while (wallet->active_status.active.count (nano_qt::status_types::synchronizing) == 0) { ASSERT_NO_ERROR (system0.poll ()); ASSERT_NO_ERROR (system1.poll ()); test_application->processEvents (); } system1.deadline_set (25s); - while (wallet->active_status.active.count (rai_qt::status_types::synchronizing) == 1) + while (wallet->active_status.active.count (nano_qt::status_types::synchronizing) == 1) { ASSERT_NO_ERROR (system0.poll ()); ASSERT_NO_ERROR (system1.poll ()); diff --git a/rai/secure/CMakeLists.txt b/nano/secure/CMakeLists.txt similarity index 84% rename from rai/secure/CMakeLists.txt rename to nano/secure/CMakeLists.txt index 38f4385c..24864c7f 100644 --- a/rai/secure/CMakeLists.txt +++ b/nano/secure/CMakeLists.txt @@ -11,7 +11,7 @@ else () endif () # Embed bootstrap representative weights in executable -if (${ACTIVE_NETWORK} MATCHES "rai_beta_network") +if (${ACTIVE_NETWORK} MATCHES "nano_beta_network") set (REP_WEIGHTS_BIN_NAME "rep_weights_beta.bin") else () set (REP_WEIGHTS_BIN_NAME "rep_weights_live.bin") @@ -20,9 +20,9 @@ endif () file (READ ${CMAKE_SOURCE_DIR}/${REP_WEIGHTS_BIN_NAME} filedata HEX) string (REGEX REPLACE "(..)" "0x\\1," filedata ${filedata}) file (WRITE ${CMAKE_BINARY_DIR}/bootstrap_weights.cpp "#include \n" - "namespace rai {\n" - " unsigned char rai_bootstrap_weights[] = {${filedata} 0x00};\n" - " size_t rai_bootstrap_weights_size = sizeof(rai_bootstrap_weights) - 1;\n" + "namespace nano {\n" + " unsigned char nano_bootstrap_weights[] = {${filedata} 0x00};\n" + " size_t nano_bootstrap_weights_size = sizeof(nano_bootstrap_weights) - 1;\n" "}\n") add_library (secure @@ -41,7 +41,7 @@ add_library (secure target_link_libraries(secure ed25519 - rai_lib + nano_lib lmdb Boost::boost Boost::system diff --git a/rai/secure/blockstore.cpp b/nano/secure/blockstore.cpp similarity index 72% rename from rai/secure/blockstore.cpp rename to nano/secure/blockstore.cpp index a4efaab3..14c80bd8 100644 --- a/rai/secure/blockstore.cpp +++ b/nano/secure/blockstore.cpp @@ -1,16 +1,16 @@ -#include -#include -#include +#include +#include +#include #include -rai::summation_visitor::summation_visitor (rai::transaction const & transaction_a, rai::block_store & store_a) : +nano::summation_visitor::summation_visitor (nano::transaction const & transaction_a, nano::block_store & store_a) : transaction (transaction_a), store (store_a) { } -void rai::summation_visitor::send_block (rai::send_block const & block_a) +void nano::summation_visitor::send_block (nano::send_block const & block_a) { assert (current->type != summation_type::invalid && current != nullptr); if (current->type == summation_type::amount) @@ -26,7 +26,7 @@ void rai::summation_visitor::send_block (rai::send_block const & block_a) } } -void rai::summation_visitor::state_block (rai::state_block const & block_a) +void nano::summation_visitor::state_block (nano::state_block const & block_a) { assert (current->type != summation_type::invalid && current != nullptr); sum_set (block_a.hashables.balance.number ()); @@ -41,7 +41,7 @@ void rai::summation_visitor::state_block (rai::state_block const & block_a) } } -void rai::summation_visitor::receive_block (rai::receive_block const & block_a) +void nano::summation_visitor::receive_block (nano::receive_block const & block_a) { assert (current->type != summation_type::invalid && current != nullptr); if (current->type == summation_type::amount) @@ -50,7 +50,7 @@ void rai::summation_visitor::receive_block (rai::receive_block const & block_a) } else { - rai::block_info block_info; + nano::block_info block_info; if (!store.block_info_get (transaction, block_a.hash (), block_info)) { sum_add (block_info.balance.number ()); @@ -64,18 +64,18 @@ void rai::summation_visitor::receive_block (rai::receive_block const & block_a) } } -void rai::summation_visitor::open_block (rai::open_block const & block_a) +void nano::summation_visitor::open_block (nano::open_block const & block_a) { assert (current->type != summation_type::invalid && current != nullptr); if (current->type == summation_type::amount) { - if (block_a.hashables.source != rai::genesis_account) + if (block_a.hashables.source != nano::genesis_account) { current->amount_hash = block_a.hashables.source; } else { - sum_set (rai::genesis_amount); + sum_set (nano::genesis_amount); current->amount_hash = 0; } } @@ -86,7 +86,7 @@ void rai::summation_visitor::open_block (rai::open_block const & block_a) } } -void rai::summation_visitor::change_block (rai::change_block const & block_a) +void nano::summation_visitor::change_block (nano::change_block const & block_a) { assert (current->type != summation_type::invalid && current != nullptr); if (current->type == summation_type::amount) @@ -96,7 +96,7 @@ void rai::summation_visitor::change_block (rai::change_block const & block_a) } else { - rai::block_info block_info; + nano::block_info block_info; if (!store.block_info_get (transaction, block_a.hash (), block_info)) { sum_add (block_info.balance.number ()); @@ -109,25 +109,25 @@ void rai::summation_visitor::change_block (rai::change_block const & block_a) } } -rai::summation_visitor::frame rai::summation_visitor::push (rai::summation_visitor::summation_type type_a, rai::block_hash const & hash_a) +nano::summation_visitor::frame nano::summation_visitor::push (nano::summation_visitor::summation_type type_a, nano::block_hash const & hash_a) { frames.emplace (type_a, type_a == summation_type::balance ? hash_a : 0, type_a == summation_type::amount ? hash_a : 0); return frames.top (); } -void rai::summation_visitor::sum_add (rai::uint128_t addend_a) +void nano::summation_visitor::sum_add (nano::uint128_t addend_a) { current->sum += addend_a; result = current->sum; } -void rai::summation_visitor::sum_set (rai::uint128_t value_a) +void nano::summation_visitor::sum_set (nano::uint128_t value_a) { current->sum = value_a; result = current->sum; } -rai::uint128_t rai::summation_visitor::compute_internal (rai::summation_visitor::summation_type type_a, rai::block_hash const & hash_a) +nano::uint128_t nano::summation_visitor::compute_internal (nano::summation_visitor::summation_type type_a, nano::block_hash const & hash_a) { push (type_a, hash_a); @@ -190,9 +190,9 @@ rai::uint128_t rai::summation_visitor::compute_internal (rai::summation_visitor: } else { - if (current->amount_hash == rai::genesis_account) + if (current->amount_hash == nano::genesis_account) { - sum_set (std::numeric_limits::max ()); + sum_set (std::numeric_limits::max ()); current->amount_hash = 0; } else @@ -219,7 +219,7 @@ rai::uint128_t rai::summation_visitor::compute_internal (rai::summation_visitor: return result; } -void rai::summation_visitor::epilogue () +void nano::summation_visitor::epilogue () { if (!current->awaiting_result) { @@ -231,24 +231,24 @@ void rai::summation_visitor::epilogue () } } -rai::uint128_t rai::summation_visitor::compute_amount (rai::block_hash const & block_hash) +nano::uint128_t nano::summation_visitor::compute_amount (nano::block_hash const & block_hash) { return compute_internal (summation_type::amount, block_hash); } -rai::uint128_t rai::summation_visitor::compute_balance (rai::block_hash const & block_hash) +nano::uint128_t nano::summation_visitor::compute_balance (nano::block_hash const & block_hash) { return compute_internal (summation_type::balance, block_hash); } -rai::representative_visitor::representative_visitor (rai::transaction const & transaction_a, rai::block_store & store_a) : +nano::representative_visitor::representative_visitor (nano::transaction const & transaction_a, nano::block_store & store_a) : transaction (transaction_a), store (store_a), result (0) { } -void rai::representative_visitor::compute (rai::block_hash const & hash_a) +void nano::representative_visitor::compute (nano::block_hash const & hash_a) { current = hash_a; while (result.is_zero ()) @@ -259,27 +259,27 @@ void rai::representative_visitor::compute (rai::block_hash const & hash_a) } } -void rai::representative_visitor::send_block (rai::send_block const & block_a) +void nano::representative_visitor::send_block (nano::send_block const & block_a) { current = block_a.previous (); } -void rai::representative_visitor::receive_block (rai::receive_block const & block_a) +void nano::representative_visitor::receive_block (nano::receive_block const & block_a) { current = block_a.previous (); } -void rai::representative_visitor::open_block (rai::open_block const & block_a) +void nano::representative_visitor::open_block (nano::open_block const & block_a) { result = block_a.hash (); } -void rai::representative_visitor::change_block (rai::change_block const & block_a) +void nano::representative_visitor::change_block (nano::change_block const & block_a) { result = block_a.hash (); } -void rai::representative_visitor::state_block (rai::state_block const & block_a) +void nano::representative_visitor::state_block (nano::state_block const & block_a) { result = block_a.hash (); } diff --git a/nano/secure/blockstore.hpp b/nano/secure/blockstore.hpp new file mode 100644 index 00000000..9d60d651 --- /dev/null +++ b/nano/secure/blockstore.hpp @@ -0,0 +1,306 @@ +#pragma once + +#include +#include + +namespace nano +{ +class transaction; +class block_store; + +/** + * Summation visitor for blocks, supporting amount and balance computations. These + * computations are mutually dependant. The natural solution is to use mutual recursion + * between balance and amount visitors, but this leads to very deep stacks. Hence, the + * summation visitor uses an iterative approach. + */ +class summation_visitor : public nano::block_visitor +{ + enum summation_type + { + invalid = 0, + balance = 1, + amount = 2 + }; + + /** Represents an invocation frame */ + class frame + { + public: + frame (summation_type type_a, nano::block_hash balance_hash_a, nano::block_hash amount_hash_a) : + type (type_a), balance_hash (balance_hash_a), amount_hash (amount_hash_a) + { + } + + /** The summation type guides the block visitor handlers */ + summation_type type{ invalid }; + /** Accumulated balance or amount */ + nano::uint128_t sum{ 0 }; + /** The current balance hash */ + nano::block_hash balance_hash{ 0 }; + /** The current amount hash */ + nano::block_hash amount_hash{ 0 }; + /** If true, this frame is awaiting an invocation result */ + bool awaiting_result{ false }; + /** Set by the invoked frame, representing the return value */ + nano::uint128_t incoming_result{ 0 }; + }; + +public: + summation_visitor (nano::transaction const &, nano::block_store &); + virtual ~summation_visitor () = default; + /** Computes the balance as of \p block_hash */ + nano::uint128_t compute_balance (nano::block_hash const & block_hash); + /** Computes the amount delta between \p block_hash and its predecessor */ + nano::uint128_t compute_amount (nano::block_hash const & block_hash); + +protected: + nano::transaction const & transaction; + nano::block_store & store; + + /** The final result */ + nano::uint128_t result{ 0 }; + /** The current invocation frame */ + frame * current{ nullptr }; + /** Invocation frames */ + std::stack frames; + /** Push a copy of \p hash of the given summation \p type */ + nano::summation_visitor::frame push (nano::summation_visitor::summation_type type, nano::block_hash const & hash); + void sum_add (nano::uint128_t addend_a); + void sum_set (nano::uint128_t value_a); + /** The epilogue yields the result to previous frame, if any */ + void epilogue (); + + nano::uint128_t compute_internal (nano::summation_visitor::summation_type type, nano::block_hash const &); + void send_block (nano::send_block const &) override; + void receive_block (nano::receive_block const &) override; + void open_block (nano::open_block const &) override; + void change_block (nano::change_block const &) override; + void state_block (nano::state_block const &) override; +}; + +/** + * Determine the representative for this block + */ +class representative_visitor : public nano::block_visitor +{ +public: + representative_visitor (nano::transaction const & transaction_a, nano::block_store & store_a); + virtual ~representative_visitor () = default; + void compute (nano::block_hash const & hash_a); + void send_block (nano::send_block const & block_a) override; + void receive_block (nano::receive_block const & block_a) override; + void open_block (nano::open_block const & block_a) override; + void change_block (nano::change_block const & block_a) override; + void state_block (nano::state_block const & block_a) override; + nano::transaction const & transaction; + nano::block_store & store; + nano::block_hash current; + nano::block_hash result; +}; +template +class store_iterator_impl +{ +public: + virtual ~store_iterator_impl () = default; + virtual nano::store_iterator_impl & operator++ () = 0; + virtual bool operator== (nano::store_iterator_impl const & other_a) const = 0; + virtual bool is_end_sentinal () const = 0; + virtual void fill (std::pair &) const = 0; + nano::store_iterator_impl & operator= (nano::store_iterator_impl const &) = delete; + bool operator== (nano::store_iterator_impl const * other_a) const + { + return (other_a != nullptr && *this == *other_a) || (other_a == nullptr && is_end_sentinal ()); + } + bool operator!= (nano::store_iterator_impl const & other_a) const + { + return !(*this == other_a); + } +}; +/** + * Iterates the key/value pairs of a transaction + */ +template +class store_iterator +{ +public: + store_iterator (std::nullptr_t) + { + } + store_iterator (std::unique_ptr> impl_a) : + impl (std::move (impl_a)) + { + impl->fill (current); + } + store_iterator (nano::store_iterator && other_a) : + current (std::move (other_a.current)), + impl (std::move (other_a.impl)) + { + } + nano::store_iterator & operator++ () + { + ++*impl; + impl->fill (current); + return *this; + } + nano::store_iterator & operator= (nano::store_iterator && other_a) + { + impl = std::move (other_a.impl); + current = std::move (other_a.current); + return *this; + } + nano::store_iterator & operator= (nano::store_iterator const &) = delete; + std::pair * operator-> () + { + return ¤t; + } + bool operator== (nano::store_iterator const & other_a) const + { + return (impl == nullptr && other_a.impl == nullptr) || (impl != nullptr && *impl == other_a.impl.get ()) || (other_a.impl != nullptr && *other_a.impl == impl.get ()); + } + bool operator!= (nano::store_iterator const & other_a) const + { + return !(*this == other_a); + } + +private: + std::pair current; + std::unique_ptr> impl; +}; + +class block_predecessor_set; + +class transaction_impl +{ +public: + virtual ~transaction_impl () = default; +}; +/** + * RAII wrapper of MDB_txn where the constructor starts the transaction + * and the destructor commits it. + */ +class transaction +{ +public: + std::unique_ptr impl; +}; + +/** + * Manages block storage and iteration + */ +class block_store +{ +public: + virtual ~block_store () = default; + virtual void initialize (nano::transaction const &, nano::genesis const &) = 0; + virtual void block_put (nano::transaction const &, nano::block_hash const &, nano::block const &, nano::block_hash const & = nano::block_hash (0), nano::epoch version = nano::epoch::epoch_0) = 0; + virtual nano::block_hash block_successor (nano::transaction const &, nano::block_hash const &) = 0; + virtual void block_successor_clear (nano::transaction const &, nano::block_hash const &) = 0; + virtual std::shared_ptr block_get (nano::transaction const &, nano::block_hash const &) = 0; + virtual std::shared_ptr block_random (nano::transaction const &) = 0; + virtual void block_del (nano::transaction const &, nano::block_hash const &) = 0; + virtual bool block_exists (nano::transaction const &, nano::block_hash const &) = 0; + virtual bool block_exists (nano::transaction const &, nano::block_type, nano::block_hash const &) = 0; + virtual nano::block_counts block_count (nano::transaction const &) = 0; + virtual bool root_exists (nano::transaction const &, nano::uint256_union const &) = 0; + + virtual void frontier_put (nano::transaction const &, nano::block_hash const &, nano::account const &) = 0; + virtual nano::account frontier_get (nano::transaction const &, nano::block_hash const &) = 0; + virtual void frontier_del (nano::transaction const &, nano::block_hash const &) = 0; + + virtual void account_put (nano::transaction const &, nano::account const &, nano::account_info const &) = 0; + virtual bool account_get (nano::transaction const &, nano::account const &, nano::account_info &) = 0; + virtual void account_del (nano::transaction const &, nano::account const &) = 0; + virtual bool account_exists (nano::transaction const &, nano::account const &) = 0; + virtual size_t account_count (nano::transaction const &) = 0; + virtual nano::store_iterator latest_v0_begin (nano::transaction const &, nano::account const &) = 0; + virtual nano::store_iterator latest_v0_begin (nano::transaction const &) = 0; + virtual nano::store_iterator latest_v0_end () = 0; + virtual nano::store_iterator latest_v1_begin (nano::transaction const &, nano::account const &) = 0; + virtual nano::store_iterator latest_v1_begin (nano::transaction const &) = 0; + virtual nano::store_iterator latest_v1_end () = 0; + virtual nano::store_iterator latest_begin (nano::transaction const &, nano::account const &) = 0; + virtual nano::store_iterator latest_begin (nano::transaction const &) = 0; + virtual nano::store_iterator latest_end () = 0; + + virtual void pending_put (nano::transaction const &, nano::pending_key const &, nano::pending_info const &) = 0; + virtual void pending_del (nano::transaction const &, nano::pending_key const &) = 0; + virtual bool pending_get (nano::transaction const &, nano::pending_key const &, nano::pending_info &) = 0; + virtual bool pending_exists (nano::transaction const &, nano::pending_key const &) = 0; + virtual nano::store_iterator pending_v0_begin (nano::transaction const &, nano::pending_key const &) = 0; + virtual nano::store_iterator pending_v0_begin (nano::transaction const &) = 0; + virtual nano::store_iterator pending_v0_end () = 0; + virtual nano::store_iterator pending_v1_begin (nano::transaction const &, nano::pending_key const &) = 0; + virtual nano::store_iterator pending_v1_begin (nano::transaction const &) = 0; + virtual nano::store_iterator pending_v1_end () = 0; + virtual nano::store_iterator pending_begin (nano::transaction const &, nano::pending_key const &) = 0; + virtual nano::store_iterator pending_begin (nano::transaction const &) = 0; + virtual nano::store_iterator pending_end () = 0; + + virtual void block_info_put (nano::transaction const &, nano::block_hash const &, nano::block_info const &) = 0; + virtual void block_info_del (nano::transaction const &, nano::block_hash const &) = 0; + virtual bool block_info_get (nano::transaction const &, nano::block_hash const &, nano::block_info &) = 0; + virtual bool block_info_exists (nano::transaction const &, nano::block_hash const &) = 0; + virtual nano::store_iterator block_info_begin (nano::transaction const &, nano::block_hash const &) = 0; + virtual nano::store_iterator block_info_begin (nano::transaction const &) = 0; + virtual nano::store_iterator block_info_end () = 0; + virtual nano::uint128_t block_balance (nano::transaction const &, nano::block_hash const &) = 0; + virtual nano::epoch block_version (nano::transaction const &, nano::block_hash const &) = 0; + static size_t const block_info_max = 32; + + virtual nano::uint128_t representation_get (nano::transaction const &, nano::account const &) = 0; + virtual void representation_put (nano::transaction const &, nano::account const &, nano::uint128_t const &) = 0; + virtual void representation_add (nano::transaction const &, nano::account const &, nano::uint128_t const &) = 0; + virtual nano::store_iterator representation_begin (nano::transaction const &) = 0; + virtual nano::store_iterator representation_end () = 0; + + virtual void unchecked_clear (nano::transaction const &) = 0; + virtual void unchecked_put (nano::transaction const &, nano::unchecked_key const &, std::shared_ptr const &) = 0; + virtual void unchecked_put (nano::transaction const &, nano::block_hash const &, std::shared_ptr const &) = 0; + virtual std::vector> unchecked_get (nano::transaction const &, nano::block_hash const &) = 0; + virtual bool unchecked_exists (nano::transaction const &, nano::unchecked_key const &) = 0; + virtual void unchecked_del (nano::transaction const &, nano::unchecked_key const &) = 0; + virtual nano::store_iterator> unchecked_begin (nano::transaction const &) = 0; + virtual nano::store_iterator> unchecked_begin (nano::transaction const &, nano::unchecked_key const &) = 0; + virtual nano::store_iterator> unchecked_end () = 0; + virtual size_t unchecked_count (nano::transaction const &) = 0; + + virtual void checksum_put (nano::transaction const &, uint64_t, uint8_t, nano::checksum const &) = 0; + virtual bool checksum_get (nano::transaction const &, uint64_t, uint8_t, nano::checksum &) = 0; + virtual void checksum_del (nano::transaction const &, uint64_t, uint8_t) = 0; + + // Return latest vote for an account from store + virtual std::shared_ptr vote_get (nano::transaction const &, nano::account const &) = 0; + // Populate vote with the next sequence number + virtual std::shared_ptr vote_generate (nano::transaction const &, nano::account const &, nano::raw_key const &, std::shared_ptr) = 0; + virtual std::shared_ptr vote_generate (nano::transaction const &, nano::account const &, nano::raw_key const &, std::vector) = 0; + // Return either vote or the stored vote with a higher sequence number + virtual std::shared_ptr vote_max (nano::transaction const &, std::shared_ptr) = 0; + // Return latest vote for an account considering the vote cache + virtual std::shared_ptr vote_current (nano::transaction const &, nano::account const &) = 0; + virtual void flush (nano::transaction const &) = 0; + virtual nano::store_iterator> vote_begin (nano::transaction const &) = 0; + virtual nano::store_iterator> vote_end () = 0; + + virtual void version_put (nano::transaction const &, int) = 0; + virtual int version_get (nano::transaction const &) = 0; + + // Requires a write transaction + virtual nano::raw_key get_node_id (nano::transaction const &) = 0; + + /** Deletes the node ID from the store */ + virtual void delete_node_id (nano::transaction const &) = 0; + + /** Start read-write transaction */ + virtual nano::transaction tx_begin_write () = 0; + + /** Start read-only transaction */ + virtual nano::transaction tx_begin_read () = 0; + + /** + * Start a read-only or read-write transaction + * @param write If true, start a read-write transaction + */ + virtual nano::transaction tx_begin (bool write = false) = 0; +}; +} diff --git a/rai/secure/common.cpp b/nano/secure/common.cpp similarity index 54% rename from rai/secure/common.cpp rename to nano/secure/common.cpp index 1b97eb24..f60b4be7 100644 --- a/rai/secure/common.cpp +++ b/nano/secure/common.cpp @@ -1,10 +1,10 @@ -#include +#include -#include -#include -#include -#include -#include +#include +#include +#include +#include +#include #include @@ -52,15 +52,15 @@ public: ledger_constants () : zero_key ("0"), test_genesis_key (test_private_key_data), - rai_test_account (test_public_key_data), - rai_beta_account (beta_public_key_data), - rai_live_account (live_public_key_data), - rai_test_genesis (test_genesis_data), - rai_beta_genesis (beta_genesis_data), - rai_live_genesis (live_genesis_data), - genesis_account (rai::rai_network == rai::rai_networks::rai_test_network ? rai_test_account : rai::rai_network == rai::rai_networks::rai_beta_network ? rai_beta_account : rai_live_account), - genesis_block (rai::rai_network == rai::rai_networks::rai_test_network ? rai_test_genesis : rai::rai_network == rai::rai_networks::rai_beta_network ? rai_beta_genesis : rai_live_genesis), - genesis_amount (std::numeric_limits::max ()), + nano_test_account (test_public_key_data), + nano_beta_account (beta_public_key_data), + nano_live_account (live_public_key_data), + nano_test_genesis (test_genesis_data), + nano_beta_genesis (beta_genesis_data), + nano_live_genesis (live_genesis_data), + genesis_account (nano::nano_network == nano::nano_networks::nano_test_network ? nano_test_account : nano::nano_network == nano::nano_networks::nano_beta_network ? nano_beta_account : nano_live_account), + genesis_block (nano::nano_network == nano::nano_networks::nano_test_network ? nano_test_genesis : nano::nano_network == nano::nano_networks::nano_beta_network ? nano_beta_genesis : nano_live_genesis), + genesis_amount (std::numeric_limits::max ()), burn_account (0) { CryptoPP::AutoSeededRandomPool random_pool; @@ -68,62 +68,62 @@ public: random_pool.GenerateBlock (not_a_block.bytes.data (), not_a_block.bytes.size ()); random_pool.GenerateBlock (not_an_account.bytes.data (), not_an_account.bytes.size ()); } - rai::keypair zero_key; - rai::keypair test_genesis_key; - rai::account rai_test_account; - rai::account rai_beta_account; - rai::account rai_live_account; - std::string rai_test_genesis; - std::string rai_beta_genesis; - std::string rai_live_genesis; - rai::account genesis_account; + nano::keypair zero_key; + nano::keypair test_genesis_key; + nano::account nano_test_account; + nano::account nano_beta_account; + nano::account nano_live_account; + std::string nano_test_genesis; + std::string nano_beta_genesis; + std::string nano_live_genesis; + nano::account genesis_account; std::string genesis_block; - rai::uint128_t genesis_amount; - rai::block_hash not_a_block; - rai::account not_an_account; - rai::account burn_account; + nano::uint128_t genesis_amount; + nano::block_hash not_a_block; + nano::account not_an_account; + nano::account burn_account; }; ledger_constants globals; } -size_t constexpr rai::send_block::size; -size_t constexpr rai::receive_block::size; -size_t constexpr rai::open_block::size; -size_t constexpr rai::change_block::size; -size_t constexpr rai::state_block::size; +size_t constexpr nano::send_block::size; +size_t constexpr nano::receive_block::size; +size_t constexpr nano::open_block::size; +size_t constexpr nano::change_block::size; +size_t constexpr nano::state_block::size; -rai::keypair const & rai::zero_key (globals.zero_key); -rai::keypair const & rai::test_genesis_key (globals.test_genesis_key); -rai::account const & rai::rai_test_account (globals.rai_test_account); -rai::account const & rai::rai_beta_account (globals.rai_beta_account); -rai::account const & rai::rai_live_account (globals.rai_live_account); -std::string const & rai::rai_test_genesis (globals.rai_test_genesis); -std::string const & rai::rai_beta_genesis (globals.rai_beta_genesis); -std::string const & rai::rai_live_genesis (globals.rai_live_genesis); +nano::keypair const & nano::zero_key (globals.zero_key); +nano::keypair const & nano::test_genesis_key (globals.test_genesis_key); +nano::account const & nano::nano_test_account (globals.nano_test_account); +nano::account const & nano::nano_beta_account (globals.nano_beta_account); +nano::account const & nano::nano_live_account (globals.nano_live_account); +std::string const & nano::nano_test_genesis (globals.nano_test_genesis); +std::string const & nano::nano_beta_genesis (globals.nano_beta_genesis); +std::string const & nano::nano_live_genesis (globals.nano_live_genesis); -rai::account const & rai::genesis_account (globals.genesis_account); -std::string const & rai::genesis_block (globals.genesis_block); -rai::uint128_t const & rai::genesis_amount (globals.genesis_amount); -rai::block_hash const & rai::not_a_block (globals.not_a_block); -rai::block_hash const & rai::not_an_account (globals.not_an_account); -rai::account const & rai::burn_account (globals.burn_account); +nano::account const & nano::genesis_account (globals.genesis_account); +std::string const & nano::genesis_block (globals.genesis_block); +nano::uint128_t const & nano::genesis_amount (globals.genesis_amount); +nano::block_hash const & nano::not_a_block (globals.not_a_block); +nano::block_hash const & nano::not_an_account (globals.not_an_account); +nano::account const & nano::burn_account (globals.burn_account); // Create a new random keypair -rai::keypair::keypair () +nano::keypair::keypair () { random_pool.GenerateBlock (prv.data.bytes.data (), prv.data.bytes.size ()); ed25519_publickey (prv.data.bytes.data (), pub.bytes.data ()); } // Create a keypair given a private key -rai::keypair::keypair (rai::raw_key && prv_a) : +nano::keypair::keypair (nano::raw_key && prv_a) : prv (std::move (prv_a)) { ed25519_publickey (prv.data.bytes.data (), pub.bytes.data ()); } // Create a keypair given a hex string of the private key -rai::keypair::keypair (std::string const & prv_a) +nano::keypair::keypair (std::string const & prv_a) { auto error (prv.data.decode_hex (prv_a)); assert (!error); @@ -131,24 +131,24 @@ rai::keypair::keypair (std::string const & prv_a) } // Serialize a block prefixed with an 8-bit typecode -void rai::serialize_block (rai::stream & stream_a, rai::block const & block_a) +void nano::serialize_block (nano::stream & stream_a, nano::block const & block_a) { write (stream_a, block_a.type ()); block_a.serialize (stream_a); } -rai::account_info::account_info () : +nano::account_info::account_info () : head (0), rep_block (0), open_block (0), balance (0), modified (0), block_count (0), -epoch (rai::epoch::epoch_0) +epoch (nano::epoch::epoch_0) { } -rai::account_info::account_info (rai::block_hash const & head_a, rai::block_hash const & rep_block_a, rai::block_hash const & open_block_a, rai::amount const & balance_a, uint64_t modified_a, uint64_t block_count_a, rai::epoch epoch_a) : +nano::account_info::account_info (nano::block_hash const & head_a, nano::block_hash const & rep_block_a, nano::block_hash const & open_block_a, nano::amount const & balance_a, uint64_t modified_a, uint64_t block_count_a, nano::epoch epoch_a) : head (head_a), rep_block (rep_block_a), open_block (open_block_a), @@ -159,7 +159,7 @@ epoch (epoch_a) { } -void rai::account_info::serialize (rai::stream & stream_a) const +void nano::account_info::serialize (nano::stream & stream_a) const { write (stream_a, head.bytes); write (stream_a, rep_block.bytes); @@ -169,7 +169,7 @@ void rai::account_info::serialize (rai::stream & stream_a) const write (stream_a, block_count); } -bool rai::account_info::deserialize (rai::stream & stream_a) +bool nano::account_info::deserialize (nano::stream & stream_a) { auto error (read (stream_a, head.bytes)); if (!error) @@ -195,17 +195,17 @@ bool rai::account_info::deserialize (rai::stream & stream_a) return error; } -bool rai::account_info::operator== (rai::account_info const & other_a) const +bool nano::account_info::operator== (nano::account_info const & other_a) const { return head == other_a.head && rep_block == other_a.rep_block && open_block == other_a.open_block && balance == other_a.balance && modified == other_a.modified && block_count == other_a.block_count && epoch == other_a.epoch; } -bool rai::account_info::operator!= (rai::account_info const & other_a) const +bool nano::account_info::operator!= (nano::account_info const & other_a) const { return !(*this == other_a); } -size_t rai::account_info::db_size () const +size_t nano::account_info::db_size () const { assert (reinterpret_cast (this) == reinterpret_cast (&head)); assert (reinterpret_cast (&head) + sizeof (head) == reinterpret_cast (&rep_block)); @@ -216,7 +216,7 @@ size_t rai::account_info::db_size () const return sizeof (head) + sizeof (rep_block) + sizeof (open_block) + sizeof (balance) + sizeof (modified) + sizeof (block_count); } -rai::block_counts::block_counts () : +nano::block_counts::block_counts () : send (0), receive (0), open (0), @@ -226,118 +226,118 @@ state_v1 (0) { } -size_t rai::block_counts::sum () +size_t nano::block_counts::sum () { return send + receive + open + change + state_v0 + state_v1; } -rai::pending_info::pending_info () : +nano::pending_info::pending_info () : source (0), amount (0), -epoch (rai::epoch::epoch_0) +epoch (nano::epoch::epoch_0) { } -rai::pending_info::pending_info (rai::account const & source_a, rai::amount const & amount_a, rai::epoch epoch_a) : +nano::pending_info::pending_info (nano::account const & source_a, nano::amount const & amount_a, nano::epoch epoch_a) : source (source_a), amount (amount_a), epoch (epoch_a) { } -void rai::pending_info::serialize (rai::stream & stream_a) const +void nano::pending_info::serialize (nano::stream & stream_a) const { - rai::write (stream_a, source.bytes); - rai::write (stream_a, amount.bytes); + nano::write (stream_a, source.bytes); + nano::write (stream_a, amount.bytes); } -bool rai::pending_info::deserialize (rai::stream & stream_a) +bool nano::pending_info::deserialize (nano::stream & stream_a) { - auto result (rai::read (stream_a, source.bytes)); + auto result (nano::read (stream_a, source.bytes)); if (!result) { - result = rai::read (stream_a, amount.bytes); + result = nano::read (stream_a, amount.bytes); } return result; } -bool rai::pending_info::operator== (rai::pending_info const & other_a) const +bool nano::pending_info::operator== (nano::pending_info const & other_a) const { return source == other_a.source && amount == other_a.amount && epoch == other_a.epoch; } -rai::pending_key::pending_key () : +nano::pending_key::pending_key () : account (0), hash (0) { } -rai::pending_key::pending_key (rai::account const & account_a, rai::block_hash const & hash_a) : +nano::pending_key::pending_key (nano::account const & account_a, nano::block_hash const & hash_a) : account (account_a), hash (hash_a) { } -void rai::pending_key::serialize (rai::stream & stream_a) const +void nano::pending_key::serialize (nano::stream & stream_a) const { - rai::write (stream_a, account.bytes); - rai::write (stream_a, hash.bytes); + nano::write (stream_a, account.bytes); + nano::write (stream_a, hash.bytes); } -bool rai::pending_key::deserialize (rai::stream & stream_a) +bool nano::pending_key::deserialize (nano::stream & stream_a) { - auto error (rai::read (stream_a, account.bytes)); + auto error (nano::read (stream_a, account.bytes)); if (!error) { - error = rai::read (stream_a, hash.bytes); + error = nano::read (stream_a, hash.bytes); } return error; } -bool rai::pending_key::operator== (rai::pending_key const & other_a) const +bool nano::pending_key::operator== (nano::pending_key const & other_a) const { return account == other_a.account && hash == other_a.hash; } -rai::block_hash rai::pending_key::key () const +nano::block_hash nano::pending_key::key () const { return account; } -rai::block_info::block_info () : +nano::block_info::block_info () : account (0), balance (0) { } -rai::block_info::block_info (rai::account const & account_a, rai::amount const & balance_a) : +nano::block_info::block_info (nano::account const & account_a, nano::amount const & balance_a) : account (account_a), balance (balance_a) { } -void rai::block_info::serialize (rai::stream & stream_a) const +void nano::block_info::serialize (nano::stream & stream_a) const { - rai::write (stream_a, account.bytes); - rai::write (stream_a, balance.bytes); + nano::write (stream_a, account.bytes); + nano::write (stream_a, balance.bytes); } -bool rai::block_info::deserialize (rai::stream & stream_a) +bool nano::block_info::deserialize (nano::stream & stream_a) { - auto error (rai::read (stream_a, account.bytes)); + auto error (nano::read (stream_a, account.bytes)); if (!error) { - error = rai::read (stream_a, balance.bytes); + error = nano::read (stream_a, balance.bytes); } return error; } -bool rai::block_info::operator== (rai::block_info const & other_a) const +bool nano::block_info::operator== (nano::block_info const & other_a) const { return account == other_a.account && balance == other_a.balance; } -bool rai::vote::operator== (rai::vote const & other_a) const +bool nano::vote::operator== (nano::vote const & other_a) const { auto blocks_equal (true); if (blocks.size () != other_a.blocks.size ()) @@ -356,14 +356,14 @@ bool rai::vote::operator== (rai::vote const & other_a) const } else if (block.which ()) { - if (boost::get (block) != boost::get (other_block)) + if (boost::get (block) != boost::get (other_block)) { blocks_equal = false; } } else { - if (!(*boost::get> (block) == *boost::get> (other_block))) + if (!(*boost::get> (block) == *boost::get> (other_block))) { blocks_equal = false; } @@ -373,12 +373,12 @@ bool rai::vote::operator== (rai::vote const & other_a) const return sequence == other_a.sequence && blocks_equal && account == other_a.account && signature == other_a.signature; } -bool rai::vote::operator!= (rai::vote const & other_a) const +bool nano::vote::operator!= (nano::vote const & other_a) const { return !(*this == other_a); } -std::string rai::vote::to_json () const +std::string nano::vote::to_json () const { std::stringstream stream; boost::property_tree::ptree tree; @@ -390,11 +390,11 @@ std::string rai::vote::to_json () const { if (block.which ()) { - blocks_tree.put ("", boost::get> (block)->to_json ()); + blocks_tree.put ("", boost::get> (block)->to_json ()); } else { - blocks_tree.put ("", boost::get> (block)->hash ().to_string ()); + blocks_tree.put ("", boost::get> (block)->hash ().to_string ()); } } tree.add_child ("blocks", blocks_tree); @@ -402,7 +402,7 @@ std::string rai::vote::to_json () const return stream.str (); } -rai::vote::vote (rai::vote const & other_a) : +nano::vote::vote (nano::vote const & other_a) : sequence (other_a.sequence), blocks (other_a.blocks), account (other_a.account), @@ -410,30 +410,30 @@ signature (other_a.signature) { } -rai::vote::vote (bool & error_a, rai::stream & stream_a, rai::block_uniquer * uniquer_a) +nano::vote::vote (bool & error_a, nano::stream & stream_a, nano::block_uniquer * uniquer_a) { error_a = deserialize (stream_a, uniquer_a); } -rai::vote::vote (bool & error_a, rai::stream & stream_a, rai::block_type type_a, rai::block_uniquer * uniquer_a) +nano::vote::vote (bool & error_a, nano::stream & stream_a, nano::block_type type_a, nano::block_uniquer * uniquer_a) { if (!error_a) { - error_a = rai::read (stream_a, account.bytes); + error_a = nano::read (stream_a, account.bytes); if (!error_a) { - error_a = rai::read (stream_a, signature.bytes); + error_a = nano::read (stream_a, signature.bytes); if (!error_a) { - error_a = rai::read (stream_a, sequence); + error_a = nano::read (stream_a, sequence); if (!error_a) { while (!error_a && stream_a.in_avail () > 0) { - if (type_a == rai::block_type::not_a_block) + if (type_a == nano::block_type::not_a_block) { - rai::block_hash block_hash; - error_a = rai::read (stream_a, block_hash); + nano::block_hash block_hash; + error_a = nano::read (stream_a, block_hash); if (!error_a) { blocks.push_back (block_hash); @@ -441,7 +441,7 @@ rai::vote::vote (bool & error_a, rai::stream & stream_a, rai::block_type type_a, } else { - std::shared_ptr block (rai::deserialize_block (stream_a, type_a, uniquer_a)); + std::shared_ptr block (nano::deserialize_block (stream_a, type_a, uniquer_a)); error_a = block == nullptr; if (!error_a) { @@ -459,15 +459,15 @@ rai::vote::vote (bool & error_a, rai::stream & stream_a, rai::block_type type_a, } } -rai::vote::vote (rai::account const & account_a, rai::raw_key const & prv_a, uint64_t sequence_a, std::shared_ptr block_a) : +nano::vote::vote (nano::account const & account_a, nano::raw_key const & prv_a, uint64_t sequence_a, std::shared_ptr block_a) : sequence (sequence_a), blocks (1, block_a), account (account_a), -signature (rai::sign_message (prv_a, account_a, hash ())) +signature (nano::sign_message (prv_a, account_a, hash ())) { } -rai::vote::vote (rai::account const & account_a, rai::raw_key const & prv_a, uint64_t sequence_a, std::vector blocks_a) : +nano::vote::vote (nano::account const & account_a, nano::raw_key const & prv_a, uint64_t sequence_a, std::vector blocks_a) : sequence (sequence_a), account (account_a) { @@ -477,10 +477,10 @@ account (account_a) { blocks.push_back (hash); } - signature = rai::sign_message (prv_a, account_a, hash ()); + signature = nano::sign_message (prv_a, account_a, hash ()); } -std::string rai::vote::hashes_string () const +std::string nano::vote::hashes_string () const { std::string result; for (auto hash : *this) @@ -491,11 +491,11 @@ std::string rai::vote::hashes_string () const return result; } -const std::string rai::vote::hash_prefix = "vote "; +const std::string nano::vote::hash_prefix = "vote "; -rai::uint256_union rai::vote::hash () const +nano::uint256_union nano::vote::hash () const { - rai::uint256_union result; + nano::uint256_union result; blake2b_state hash; blake2b_init (&hash, sizeof (result.bytes)); if (blocks.size () > 1 || (blocks.size () > 0 && blocks[0].which ())) @@ -517,9 +517,9 @@ rai::uint256_union rai::vote::hash () const return result; } -rai::uint256_union rai::vote::full_hash () const +nano::uint256_union nano::vote::full_hash () const { - rai::uint256_union result; + nano::uint256_union result; blake2b_state state; blake2b_init (&state, sizeof (result.bytes)); blake2b_update (&state, hash ().bytes.data (), sizeof (hash ().bytes)); @@ -529,7 +529,7 @@ rai::uint256_union rai::vote::full_hash () const return result; } -void rai::vote::serialize (rai::stream & stream_a, rai::block_type type) +void nano::vote::serialize (nano::stream & stream_a, nano::block_type type) { write (stream_a, account); write (stream_a, signature); @@ -538,24 +538,24 @@ void rai::vote::serialize (rai::stream & stream_a, rai::block_type type) { if (block.which ()) { - assert (type == rai::block_type::not_a_block); - write (stream_a, boost::get (block)); + assert (type == nano::block_type::not_a_block); + write (stream_a, boost::get (block)); } else { - if (type == rai::block_type::not_a_block) + if (type == nano::block_type::not_a_block) { - write (stream_a, boost::get> (block)->hash ()); + write (stream_a, boost::get> (block)->hash ()); } else { - boost::get> (block)->serialize (stream_a); + boost::get> (block)->serialize (stream_a); } } } } -void rai::vote::serialize (rai::stream & stream_a) +void nano::vote::serialize (nano::stream & stream_a) { write (stream_a, account); write (stream_a, signature); @@ -564,17 +564,17 @@ void rai::vote::serialize (rai::stream & stream_a) { if (block.which ()) { - write (stream_a, rai::block_type::not_a_block); - write (stream_a, boost::get (block)); + write (stream_a, nano::block_type::not_a_block); + write (stream_a, boost::get (block)); } else { - rai::serialize_block (stream_a, *boost::get> (block)); + nano::serialize_block (stream_a, *boost::get> (block)); } } } -bool rai::vote::deserialize (rai::stream & stream_a, rai::block_uniquer * uniquer_a) +bool nano::vote::deserialize (nano::stream & stream_a, nano::block_uniquer * uniquer_a) { auto result (read (stream_a, account)); if (!result) @@ -585,10 +585,10 @@ bool rai::vote::deserialize (rai::stream & stream_a, rai::block_uniquer * unique result = read (stream_a, sequence); if (!result) { - rai::block_type type; + nano::block_type type; while (!result) { - if (rai::read (stream_a, type)) + if (nano::read (stream_a, type)) { if (blocks.empty ()) { @@ -598,10 +598,10 @@ bool rai::vote::deserialize (rai::stream & stream_a, rai::block_uniquer * unique } if (!result) { - if (type == rai::block_type::not_a_block) + if (type == nano::block_type::not_a_block) { - rai::block_hash block_hash; - result = rai::read (stream_a, block_hash); + nano::block_hash block_hash; + result = nano::read (stream_a, block_hash); if (!result) { blocks.push_back (block_hash); @@ -609,7 +609,7 @@ bool rai::vote::deserialize (rai::stream & stream_a, rai::block_uniquer * unique } else { - std::shared_ptr block (rai::deserialize_block (stream_a, type, uniquer_a)); + std::shared_ptr block (nano::deserialize_block (stream_a, type, uniquer_a)); result = block == nullptr; if (!result) { @@ -624,51 +624,51 @@ bool rai::vote::deserialize (rai::stream & stream_a, rai::block_uniquer * unique return result; } -bool rai::vote::validate () +bool nano::vote::validate () { - auto result (rai::validate_message (account, hash (), signature)); + auto result (nano::validate_message (account, hash (), signature)); return result; } -rai::block_hash rai::iterate_vote_blocks_as_hash::operator() (boost::variant, rai::block_hash> const & item) const +nano::block_hash nano::iterate_vote_blocks_as_hash::operator() (boost::variant, nano::block_hash> const & item) const { - rai::block_hash result; + nano::block_hash result; if (item.which ()) { - result = boost::get (item); + result = boost::get (item); } else { - result = boost::get> (item)->hash (); + result = boost::get> (item)->hash (); } return result; } -boost::transform_iterator rai::vote::begin () const +boost::transform_iterator nano::vote::begin () const { - return boost::transform_iterator (blocks.begin (), rai::iterate_vote_blocks_as_hash ()); + return boost::transform_iterator (blocks.begin (), nano::iterate_vote_blocks_as_hash ()); } -boost::transform_iterator rai::vote::end () const +boost::transform_iterator nano::vote::end () const { - return boost::transform_iterator (blocks.end (), rai::iterate_vote_blocks_as_hash ()); + return boost::transform_iterator (blocks.end (), nano::iterate_vote_blocks_as_hash ()); } -rai::vote_uniquer::vote_uniquer (rai::block_uniquer & uniquer_a) : +nano::vote_uniquer::vote_uniquer (nano::block_uniquer & uniquer_a) : uniquer (uniquer_a) { } -std::shared_ptr rai::vote_uniquer::unique (std::shared_ptr vote_a) +std::shared_ptr nano::vote_uniquer::unique (std::shared_ptr vote_a) { auto result (vote_a); if (result != nullptr) { if (!result->blocks[0].which ()) { - result->blocks[0] = uniquer.unique (boost::get> (result->blocks[0])); + result->blocks[0] = uniquer.unique (boost::get> (result->blocks[0])); } - rai::uint256_union key (vote_a->full_hash ()); + nano::uint256_union key (vote_a->full_hash ()); std::lock_guard lock (mutex); auto & existing (votes[key]); if (auto block_l = existing.lock ()) @@ -681,7 +681,7 @@ std::shared_ptr rai::vote_uniquer::unique (std::shared_ptr } for (auto i (0); i < cleanup_count && votes.size () > 0; ++i) { - auto random_offset (rai::random_pool.GenerateWord32 (0, votes.size () - 1)); + auto random_offset (nano::random_pool.GenerateWord32 (0, votes.size () - 1)); auto existing (std::next (votes.begin (), random_offset)); if (existing == votes.end ()) { @@ -703,22 +703,22 @@ std::shared_ptr rai::vote_uniquer::unique (std::shared_ptr return result; } -size_t rai::vote_uniquer::size () +size_t nano::vote_uniquer::size () { std::lock_guard lock (mutex); return votes.size (); } -rai::genesis::genesis () +nano::genesis::genesis () { boost::property_tree::ptree tree; - std::stringstream istream (rai::genesis_block); + std::stringstream istream (nano::genesis_block); boost::property_tree::read_json (istream, tree); - open = rai::deserialize_block_json (tree); + open = nano::deserialize_block_json (tree); assert (open != nullptr); } -rai::block_hash rai::genesis::hash () const +nano::block_hash nano::genesis::hash () const { return open->hash (); } diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp new file mode 100644 index 00000000..62e824c9 --- /dev/null +++ b/nano/secure/common.hpp @@ -0,0 +1,256 @@ +#pragma once + +#include +#include +#include + +#include +#include +#include + +#include + +#include + +namespace boost +{ +template <> +struct hash<::nano::uint256_union> +{ + size_t operator() (::nano::uint256_union const & value_a) const + { + std::hash<::nano::uint256_union> hash; + return hash (value_a); + } +}; +} +namespace nano +{ +const uint8_t protocol_version = 0x0f; +const uint8_t protocol_version_min = 0x0d; +const uint8_t node_id_version = 0x0c; + +/* + * Do not bootstrap from nodes older than this version. + * Also, on the beta network do not process messages from + * nodes older than this version. + */ +const uint8_t protocol_version_reasonable_min = 0x0d; + +/** + * A key pair. The private key is generated from the random pool, or passed in + * as a hex string. The public key is derived using ed25519. + */ +class keypair +{ +public: + keypair (); + keypair (std::string const &); + keypair (nano::raw_key &&); + nano::public_key pub; + nano::raw_key prv; +}; + +/** + * Tag for which epoch an entry belongs to + */ +enum class epoch : uint8_t +{ + invalid = 0, + unspecified = 1, + epoch_0 = 2, + epoch_1 = 3 +}; + +/** + * Latest information about an account + */ +class account_info +{ +public: + account_info (); + account_info (nano::account_info const &) = default; + account_info (nano::block_hash const &, nano::block_hash const &, nano::block_hash const &, nano::amount const &, uint64_t, uint64_t, epoch); + void serialize (nano::stream &) const; + bool deserialize (nano::stream &); + bool operator== (nano::account_info const &) const; + bool operator!= (nano::account_info const &) const; + size_t db_size () const; + nano::block_hash head; + nano::block_hash rep_block; + nano::block_hash open_block; + nano::amount balance; + /** Seconds since posix epoch */ + uint64_t modified; + uint64_t block_count; + nano::epoch epoch; +}; + +/** + * Information on an uncollected send + */ +class pending_info +{ +public: + pending_info (); + pending_info (nano::account const &, nano::amount const &, epoch); + void serialize (nano::stream &) const; + bool deserialize (nano::stream &); + bool operator== (nano::pending_info const &) const; + nano::account source; + nano::amount amount; + nano::epoch epoch; +}; +class pending_key +{ +public: + pending_key (); + pending_key (nano::account const &, nano::block_hash const &); + void serialize (nano::stream &) const; + bool deserialize (nano::stream &); + bool operator== (nano::pending_key const &) const; + nano::account account; + nano::block_hash hash; + nano::block_hash key () const; +}; +// Internally unchecked_key is equal to pending_key (2x uint256_union) +using unchecked_key = pending_key; + +class block_info +{ +public: + block_info (); + block_info (nano::account const &, nano::amount const &); + void serialize (nano::stream &) const; + bool deserialize (nano::stream &); + bool operator== (nano::block_info const &) const; + nano::account account; + nano::amount balance; +}; +class block_counts +{ +public: + block_counts (); + size_t sum (); + size_t send; + size_t receive; + size_t open; + size_t change; + size_t state_v0; + size_t state_v1; +}; +typedef std::vector, nano::block_hash>>::const_iterator vote_blocks_vec_iter; +class iterate_vote_blocks_as_hash +{ +public: + iterate_vote_blocks_as_hash () = default; + nano::block_hash operator() (boost::variant, nano::block_hash> const & item) const; +}; +class vote +{ +public: + vote () = default; + vote (nano::vote const &); + vote (bool &, nano::stream &, nano::block_uniquer * = nullptr); + vote (bool &, nano::stream &, nano::block_type, nano::block_uniquer * = nullptr); + vote (nano::account const &, nano::raw_key const &, uint64_t, std::shared_ptr); + vote (nano::account const &, nano::raw_key const &, uint64_t, std::vector); + std::string hashes_string () const; + nano::uint256_union hash () const; + nano::uint256_union full_hash () const; + bool operator== (nano::vote const &) const; + bool operator!= (nano::vote const &) const; + void serialize (nano::stream &, nano::block_type); + void serialize (nano::stream &); + bool deserialize (nano::stream &, nano::block_uniquer * = nullptr); + bool validate (); + boost::transform_iterator begin () const; + boost::transform_iterator end () const; + std::string to_json () const; + // Vote round sequence number + uint64_t sequence; + // The blocks, or block hashes, that this vote is for + std::vector, nano::block_hash>> blocks; + // Account that's voting + nano::account account; + // Signature of sequence + block hashes + nano::signature signature; + static const std::string hash_prefix; +}; +/** + * This class serves to find and return unique variants of a vote in order to minimize memory usage + */ +class vote_uniquer +{ +public: + vote_uniquer (nano::block_uniquer &); + std::shared_ptr unique (std::shared_ptr); + size_t size (); + +private: + nano::block_uniquer & uniquer; + std::mutex mutex; + std::unordered_map> votes; + static unsigned constexpr cleanup_count = 2; +}; +enum class vote_code +{ + invalid, // Vote is not signed correctly + replay, // Vote does not have the highest sequence number, it's a replay + vote // Vote has the highest sequence number +}; + +enum class process_result +{ + progress, // Hasn't been seen before, signed correctly + bad_signature, // Signature was bad, forged or transmission error + old, // Already seen and was valid + negative_spend, // Malicious attempt to spend a negative amount + fork, // Malicious fork based on previous + unreceivable, // Source block doesn't exist, has already been received, or requires an account upgrade (epoch blocks) + gap_previous, // Block marked as previous is unknown + gap_source, // Block marked as source is unknown + opened_burn_account, // The impossible happened, someone found the private key associated with the public key '0'. + balance_mismatch, // Balance and amount delta don't match + representative_mismatch, // Representative is changed when it is not allowed + block_position // This block cannot follow the previous block +}; +class process_return +{ +public: + nano::process_result code; + nano::account account; + nano::amount amount; + nano::account pending_account; + boost::optional state_is_send; +}; +enum class tally_result +{ + vote, + changed, + confirm +}; +extern nano::keypair const & zero_key; +extern nano::keypair const & test_genesis_key; +extern nano::account const & nano_test_account; +extern nano::account const & nano_beta_account; +extern nano::account const & nano_live_account; +extern std::string const & nano_test_genesis; +extern std::string const & nano_beta_genesis; +extern std::string const & nano_live_genesis; +extern std::string const & genesis_block; +extern nano::account const & genesis_account; +extern nano::account const & burn_account; +extern nano::uint128_t const & genesis_amount; +// A block hash that compares inequal to any real block hash +extern nano::block_hash const & not_a_block; +// An account number that compares inequal to any real account number +extern nano::block_hash const & not_an_account; +class genesis +{ +public: + explicit genesis (); + nano::block_hash hash () const; + std::shared_ptr open; +}; +} diff --git a/rai/secure/ledger.cpp b/nano/secure/ledger.cpp similarity index 51% rename from rai/secure/ledger.cpp rename to nano/secure/ledger.cpp index 67be8e0a..14ed2441 100644 --- a/rai/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -1,32 +1,32 @@ -#include -#include -#include -#include +#include +#include +#include +#include namespace { /** * Roll back the visited block */ -class rollback_visitor : public rai::block_visitor +class rollback_visitor : public nano::block_visitor { public: - rollback_visitor (rai::transaction const & transaction_a, rai::ledger & ledger_a) : + rollback_visitor (nano::transaction const & transaction_a, nano::ledger & ledger_a) : transaction (transaction_a), ledger (ledger_a) { } virtual ~rollback_visitor () = default; - void send_block (rai::send_block const & block_a) override + void send_block (nano::send_block const & block_a) override { auto hash (block_a.hash ()); - rai::pending_info pending; - rai::pending_key key (block_a.hashables.destination, hash); + nano::pending_info pending; + nano::pending_key key (block_a.hashables.destination, hash); while (ledger.store.pending_get (transaction, key, pending)) { ledger.rollback (transaction, ledger.latest (transaction, block_a.hashables.destination)); } - rai::account_info info; + nano::account_info info; auto error (ledger.store.account_get (transaction, pending.source, info)); assert (!error); ledger.store.pending_del (transaction, key); @@ -40,22 +40,22 @@ public: { ledger.store.block_info_del (transaction, hash); } - ledger.stats.inc (rai::stat::type::rollback, rai::stat::detail::send); + ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::send); } - void receive_block (rai::receive_block const & block_a) override + void receive_block (nano::receive_block const & block_a) override { auto hash (block_a.hash ()); auto representative (ledger.representative (transaction, block_a.hashables.previous)); auto amount (ledger.amount (transaction, block_a.hashables.source)); auto destination_account (ledger.account (transaction, hash)); auto source_account (ledger.account (transaction, block_a.hashables.source)); - rai::account_info info; + nano::account_info info; auto error (ledger.store.account_get (transaction, destination_account, info)); assert (!error); ledger.store.representation_add (transaction, ledger.representative (transaction, hash), 0 - amount); ledger.change_latest (transaction, destination_account, block_a.hashables.previous, representative, ledger.balance (transaction, block_a.hashables.previous), info.block_count - 1); ledger.store.block_del (transaction, hash); - ledger.store.pending_put (transaction, rai::pending_key (destination_account, block_a.hashables.source), { source_account, amount, rai::epoch::epoch_0 }); + ledger.store.pending_put (transaction, nano::pending_key (destination_account, block_a.hashables.source), { source_account, amount, nano::epoch::epoch_0 }); ledger.store.frontier_del (transaction, hash); ledger.store.frontier_put (transaction, block_a.hashables.previous, destination_account); ledger.store.block_successor_clear (transaction, block_a.hashables.previous); @@ -63,9 +63,9 @@ public: { ledger.store.block_info_del (transaction, hash); } - ledger.stats.inc (rai::stat::type::rollback, rai::stat::detail::receive); + ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::receive); } - void open_block (rai::open_block const & block_a) override + void open_block (nano::open_block const & block_a) override { auto hash (block_a.hash ()); auto amount (ledger.amount (transaction, block_a.hashables.source)); @@ -74,16 +74,16 @@ public: ledger.store.representation_add (transaction, ledger.representative (transaction, hash), 0 - amount); ledger.change_latest (transaction, destination_account, 0, 0, 0, 0); ledger.store.block_del (transaction, hash); - ledger.store.pending_put (transaction, rai::pending_key (destination_account, block_a.hashables.source), { source_account, amount, rai::epoch::epoch_0 }); + ledger.store.pending_put (transaction, nano::pending_key (destination_account, block_a.hashables.source), { source_account, amount, nano::epoch::epoch_0 }); ledger.store.frontier_del (transaction, hash); - ledger.stats.inc (rai::stat::type::rollback, rai::stat::detail::open); + ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::open); } - void change_block (rai::change_block const & block_a) override + void change_block (nano::change_block const & block_a) override { auto hash (block_a.hash ()); auto representative (ledger.representative (transaction, block_a.hashables.previous)); auto account (ledger.account (transaction, block_a.hashables.previous)); - rai::account_info info; + nano::account_info info; auto error (ledger.store.account_get (transaction, account, info)); assert (!error); auto balance (ledger.balance (transaction, block_a.hashables.previous)); @@ -98,12 +98,12 @@ public: { ledger.store.block_info_del (transaction, hash); } - ledger.stats.inc (rai::stat::type::rollback, rai::stat::detail::change); + ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::change); } - void state_block (rai::state_block const & block_a) override + void state_block (nano::state_block const & block_a) override { auto hash (block_a.hash ()); - rai::block_hash representative (0); + nano::block_hash representative (0); if (!block_a.hashables.previous.is_zero ()) { representative = ledger.representative (transaction, block_a.hashables.previous); @@ -118,25 +118,25 @@ public: ledger.store.representation_add (transaction, representative, balance); } - rai::account_info info; + nano::account_info info; auto error (ledger.store.account_get (transaction, block_a.hashables.account, info)); if (is_send) { - rai::pending_key key (block_a.hashables.link, hash); + nano::pending_key key (block_a.hashables.link, hash); while (!ledger.store.pending_exists (transaction, key)) { ledger.rollback (transaction, ledger.latest (transaction, block_a.hashables.link)); } ledger.store.pending_del (transaction, key); - ledger.stats.inc (rai::stat::type::rollback, rai::stat::detail::send); + ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::send); } else if (!block_a.hashables.link.is_zero () && !ledger.is_epoch_link (block_a.hashables.link)) { auto source_version (ledger.store.block_version (transaction, block_a.hashables.link)); - rai::pending_info pending_info (ledger.account (transaction, block_a.hashables.link), block_a.hashables.balance.number () - balance, source_version); - ledger.store.pending_put (transaction, rai::pending_key (block_a.hashables.account, block_a.hashables.link), pending_info); - ledger.stats.inc (rai::stat::type::rollback, rai::stat::detail::receive); + nano::pending_info pending_info (ledger.account (transaction, block_a.hashables.link), block_a.hashables.balance.number () - balance, source_version); + ledger.store.pending_put (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link), pending_info); + ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::receive); } assert (!error); @@ -147,51 +147,51 @@ public: if (previous != nullptr) { ledger.store.block_successor_clear (transaction, block_a.hashables.previous); - if (previous->type () < rai::block_type::state) + if (previous->type () < nano::block_type::state) { ledger.store.frontier_put (transaction, block_a.hashables.previous, block_a.hashables.account); } } else { - ledger.stats.inc (rai::stat::type::rollback, rai::stat::detail::open); + ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::open); } ledger.store.block_del (transaction, hash); } - rai::transaction const & transaction; - rai::ledger & ledger; + nano::transaction const & transaction; + nano::ledger & ledger; }; -class ledger_processor : public rai::block_visitor +class ledger_processor : public nano::block_visitor { public: - ledger_processor (rai::ledger &, rai::transaction const &, bool = false); + ledger_processor (nano::ledger &, nano::transaction const &, bool = false); virtual ~ledger_processor () = default; - void send_block (rai::send_block const &) override; - void receive_block (rai::receive_block const &) override; - void open_block (rai::open_block const &) override; - void change_block (rai::change_block const &) override; - void state_block (rai::state_block const &) override; - void state_block_impl (rai::state_block const &); - void epoch_block_impl (rai::state_block const &); - rai::ledger & ledger; - rai::transaction const & transaction; + void send_block (nano::send_block const &) override; + void receive_block (nano::receive_block const &) override; + void open_block (nano::open_block const &) override; + void change_block (nano::change_block const &) override; + void state_block (nano::state_block const &) override; + void state_block_impl (nano::state_block const &); + void epoch_block_impl (nano::state_block const &); + nano::ledger & ledger; + nano::transaction const & transaction; bool valid_signature; - rai::process_return result; + nano::process_return result; }; -void ledger_processor::state_block (rai::state_block const & block_a) +void ledger_processor::state_block (nano::state_block const & block_a) { - result.code = rai::process_result::progress; + result.code = nano::process_result::progress; auto is_epoch_block (false); // Check if this is an epoch block if (!ledger.epoch_link.is_zero () && ledger.is_epoch_link (block_a.hashables.link)) { - rai::amount prev_balance (0); + nano::amount prev_balance (0); if (!block_a.hashables.previous.is_zero ()) { - result.code = ledger.store.block_exists (transaction, block_a.hashables.previous) ? rai::process_result::progress : rai::process_result::gap_previous; - if (result.code == rai::process_result::progress) + result.code = ledger.store.block_exists (transaction, block_a.hashables.previous) ? nano::process_result::progress : nano::process_result::gap_previous; + if (result.code == nano::process_result::progress) { prev_balance = ledger.balance (transaction, block_a.hashables.previous); } @@ -201,7 +201,7 @@ void ledger_processor::state_block (rai::state_block const & block_a) is_epoch_block = true; } } - if (result.code == rai::process_result::progress) + if (result.code == nano::process_result::progress) { if (is_epoch_block) { @@ -214,25 +214,25 @@ void ledger_processor::state_block (rai::state_block const & block_a) } } -void ledger_processor::state_block_impl (rai::state_block const & block_a) +void ledger_processor::state_block_impl (nano::state_block const & block_a) { auto hash (block_a.hash ()); auto existing (ledger.store.block_exists (transaction, block_a.type (), hash)); - result.code = existing ? rai::process_result::old : rai::process_result::progress; // Have we seen this block before? (Unambiguous) - if (result.code == rai::process_result::progress) + result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Unambiguous) + if (result.code == nano::process_result::progress) { // Revalidate blocks with epoch links if (!valid_signature || ledger.is_epoch_link (block_a.hashables.link)) { - result.code = validate_message (block_a.hashables.account, hash, block_a.signature) ? rai::process_result::bad_signature : rai::process_result::progress; // Is this block signed correctly (Unambiguous) + result.code = validate_message (block_a.hashables.account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Unambiguous) } - if (result.code == rai::process_result::progress) + if (result.code == nano::process_result::progress) { - result.code = block_a.hashables.account.is_zero () ? rai::process_result::opened_burn_account : rai::process_result::progress; // Is this for the burn account? (Unambiguous) - if (result.code == rai::process_result::progress) + result.code = block_a.hashables.account.is_zero () ? nano::process_result::opened_burn_account : nano::process_result::progress; // Is this for the burn account? (Unambiguous) + if (result.code == nano::process_result::progress) { - rai::epoch epoch (rai::epoch::epoch_0); - rai::account_info info; + nano::epoch epoch (nano::epoch::epoch_0); + nano::account_info info; result.amount = block_a.hashables.balance; auto is_send (false); auto account_error (ledger.store.account_get (transaction, block_a.hashables.account, info)); @@ -240,42 +240,42 @@ void ledger_processor::state_block_impl (rai::state_block const & block_a) { epoch = info.epoch; // Account already exists - result.code = block_a.hashables.previous.is_zero () ? rai::process_result::fork : rai::process_result::progress; // Has this account already been opened? (Ambigious) - if (result.code == rai::process_result::progress) + result.code = block_a.hashables.previous.is_zero () ? nano::process_result::fork : nano::process_result::progress; // Has this account already been opened? (Ambigious) + if (result.code == nano::process_result::progress) { - result.code = ledger.store.block_exists (transaction, block_a.hashables.previous) ? rai::process_result::progress : rai::process_result::gap_previous; // Does the previous block exist in the ledger? (Unambigious) - if (result.code == rai::process_result::progress) + result.code = ledger.store.block_exists (transaction, block_a.hashables.previous) ? nano::process_result::progress : nano::process_result::gap_previous; // Does the previous block exist in the ledger? (Unambigious) + if (result.code == nano::process_result::progress) { is_send = block_a.hashables.balance < info.balance; result.amount = is_send ? (info.balance.number () - result.amount.number ()) : (result.amount.number () - info.balance.number ()); - result.code = block_a.hashables.previous == info.head ? rai::process_result::progress : rai::process_result::fork; // Is the previous block the account's head block? (Ambigious) + result.code = block_a.hashables.previous == info.head ? nano::process_result::progress : nano::process_result::fork; // Is the previous block the account's head block? (Ambigious) } } } else { // Account does not yet exists - result.code = block_a.previous ().is_zero () ? rai::process_result::progress : rai::process_result::gap_previous; // Does the first block in an account yield 0 for previous() ? (Unambigious) - if (result.code == rai::process_result::progress) + result.code = block_a.previous ().is_zero () ? nano::process_result::progress : nano::process_result::gap_previous; // Does the first block in an account yield 0 for previous() ? (Unambigious) + if (result.code == nano::process_result::progress) { - result.code = !block_a.hashables.link.is_zero () ? rai::process_result::progress : rai::process_result::gap_source; // Is the first block receiving from a send ? (Unambigious) + result.code = !block_a.hashables.link.is_zero () ? nano::process_result::progress : nano::process_result::gap_source; // Is the first block receiving from a send ? (Unambigious) } } - if (result.code == rai::process_result::progress) + if (result.code == nano::process_result::progress) { if (!is_send) { if (!block_a.hashables.link.is_zero ()) { - result.code = (ledger.store.block_exists (transaction, rai::block_type::state, block_a.hashables.link) || ledger.store.block_exists (transaction, rai::block_type::send, block_a.hashables.link)) ? rai::process_result::progress : rai::process_result::gap_source; // Have we seen the source block already? (Harmless) - if (result.code == rai::process_result::progress) + result.code = (ledger.store.block_exists (transaction, nano::block_type::state, block_a.hashables.link) || ledger.store.block_exists (transaction, nano::block_type::send, block_a.hashables.link)) ? nano::process_result::progress : nano::process_result::gap_source; // Have we seen the source block already? (Harmless) + if (result.code == nano::process_result::progress) { - rai::pending_key key (block_a.hashables.account, block_a.hashables.link); - rai::pending_info pending; - result.code = ledger.store.pending_get (transaction, key, pending) ? rai::process_result::unreceivable : rai::process_result::progress; // Has this source already been received (Malformed) - if (result.code == rai::process_result::progress) + nano::pending_key key (block_a.hashables.account, block_a.hashables.link); + nano::pending_info pending; + result.code = ledger.store.pending_get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed) + if (result.code == nano::process_result::progress) { - result.code = result.amount == pending.amount ? rai::process_result::progress : rai::process_result::balance_mismatch; + result.code = result.amount == pending.amount ? nano::process_result::progress : nano::process_result::balance_mismatch; epoch = std::max (epoch, pending.epoch); } } @@ -283,13 +283,13 @@ void ledger_processor::state_block_impl (rai::state_block const & block_a) else { // If there's no link, the balance must remain the same, only the representative can change - result.code = result.amount.is_zero () ? rai::process_result::progress : rai::process_result::balance_mismatch; + result.code = result.amount.is_zero () ? nano::process_result::progress : nano::process_result::balance_mismatch; } } } - if (result.code == rai::process_result::progress) + if (result.code == nano::process_result::progress) { - ledger.stats.inc (rai::stat::type::ledger, rai::stat::detail::state_block); + ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::state_block); result.state_is_send = is_send; ledger.store.block_put (transaction, hash, block_a, 0, epoch); @@ -303,13 +303,13 @@ void ledger_processor::state_block_impl (rai::state_block const & block_a) if (is_send) { - rai::pending_key key (block_a.hashables.link, hash); - rai::pending_info info (block_a.hashables.account, result.amount.number (), epoch); + nano::pending_key key (block_a.hashables.link, hash); + nano::pending_info info (block_a.hashables.account, result.amount.number (), epoch); ledger.store.pending_put (transaction, key, info); } else if (!block_a.hashables.link.is_zero ()) { - ledger.store.pending_del (transaction, rai::pending_key (block_a.hashables.account, block_a.hashables.link)); + ledger.store.pending_del (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link)); } ledger.change_latest (transaction, block_a.hashables.account, hash, hash, block_a.hashables.balance, info.block_count + 1, true, epoch); @@ -325,57 +325,57 @@ void ledger_processor::state_block_impl (rai::state_block const & block_a) } } -void ledger_processor::epoch_block_impl (rai::state_block const & block_a) +void ledger_processor::epoch_block_impl (nano::state_block const & block_a) { auto hash (block_a.hash ()); auto existing (ledger.store.block_exists (transaction, block_a.type (), hash)); - result.code = existing ? rai::process_result::old : rai::process_result::progress; // Have we seen this block before? (Unambiguous) - if (result.code == rai::process_result::progress) + result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Unambiguous) + if (result.code == nano::process_result::progress) { - result.code = validate_message (ledger.epoch_signer, hash, block_a.signature) ? rai::process_result::bad_signature : rai::process_result::progress; // Is this block signed correctly (Unambiguous) - if (result.code == rai::process_result::progress) + result.code = validate_message (ledger.epoch_signer, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Unambiguous) + if (result.code == nano::process_result::progress) { - result.code = block_a.hashables.account.is_zero () ? rai::process_result::opened_burn_account : rai::process_result::progress; // Is this for the burn account? (Unambiguous) - if (result.code == rai::process_result::progress) + result.code = block_a.hashables.account.is_zero () ? nano::process_result::opened_burn_account : nano::process_result::progress; // Is this for the burn account? (Unambiguous) + if (result.code == nano::process_result::progress) { - rai::account_info info; + nano::account_info info; auto account_error (ledger.store.account_get (transaction, block_a.hashables.account, info)); if (!account_error) { // Account already exists - result.code = block_a.hashables.previous.is_zero () ? rai::process_result::fork : rai::process_result::progress; // Has this account already been opened? (Ambigious) - if (result.code == rai::process_result::progress) + result.code = block_a.hashables.previous.is_zero () ? nano::process_result::fork : nano::process_result::progress; // Has this account already been opened? (Ambigious) + if (result.code == nano::process_result::progress) { - result.code = ledger.store.block_exists (transaction, block_a.hashables.previous) ? rai::process_result::progress : rai::process_result::gap_previous; // Does the previous block exist in the ledger? (Unambigious) - if (result.code == rai::process_result::progress) + result.code = ledger.store.block_exists (transaction, block_a.hashables.previous) ? nano::process_result::progress : nano::process_result::gap_previous; // Does the previous block exist in the ledger? (Unambigious) + if (result.code == nano::process_result::progress) { - result.code = block_a.hashables.previous == info.head ? rai::process_result::progress : rai::process_result::fork; // Is the previous block the account's head block? (Ambigious) - if (result.code == rai::process_result::progress) + result.code = block_a.hashables.previous == info.head ? nano::process_result::progress : nano::process_result::fork; // Is the previous block the account's head block? (Ambigious) + if (result.code == nano::process_result::progress) { auto last_rep_block (ledger.store.block_get (transaction, info.rep_block)); assert (last_rep_block != nullptr); - result.code = block_a.hashables.representative == last_rep_block->representative () ? rai::process_result::progress : rai::process_result::representative_mismatch; + result.code = block_a.hashables.representative == last_rep_block->representative () ? nano::process_result::progress : nano::process_result::representative_mismatch; } } } } else { - result.code = block_a.hashables.representative.is_zero () ? rai::process_result::progress : rai::process_result::representative_mismatch; + result.code = block_a.hashables.representative.is_zero () ? nano::process_result::progress : nano::process_result::representative_mismatch; } - if (result.code == rai::process_result::progress) + if (result.code == nano::process_result::progress) { - result.code = info.epoch == rai::epoch::epoch_0 ? rai::process_result::progress : rai::process_result::block_position; - if (result.code == rai::process_result::progress) + result.code = info.epoch == nano::epoch::epoch_0 ? nano::process_result::progress : nano::process_result::block_position; + if (result.code == nano::process_result::progress) { - result.code = block_a.hashables.balance == info.balance ? rai::process_result::progress : rai::process_result::balance_mismatch; - if (result.code == rai::process_result::progress) + result.code = block_a.hashables.balance == info.balance ? nano::process_result::progress : nano::process_result::balance_mismatch; + if (result.code == nano::process_result::progress) { - ledger.stats.inc (rai::stat::type::ledger, rai::stat::detail::epoch_block); + ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::epoch_block); result.account = block_a.hashables.account; result.amount = 0; - ledger.store.block_put (transaction, hash, block_a, 0, rai::epoch::epoch_1); - ledger.change_latest (transaction, block_a.hashables.account, hash, hash, info.balance, info.block_count + 1, true, rai::epoch::epoch_1); + ledger.store.block_put (transaction, hash, block_a, 0, nano::epoch::epoch_1); + ledger.change_latest (transaction, block_a.hashables.account, hash, hash, info.balance, info.block_count + 1, true, nano::epoch::epoch_1); if (!ledger.store.frontier_get (transaction, info.head).is_zero ()) { ledger.store.frontier_del (transaction, info.head); @@ -388,30 +388,30 @@ void ledger_processor::epoch_block_impl (rai::state_block const & block_a) } } -void ledger_processor::change_block (rai::change_block const & block_a) +void ledger_processor::change_block (nano::change_block const & block_a) { auto hash (block_a.hash ()); auto existing (ledger.store.block_exists (transaction, block_a.type (), hash)); - result.code = existing ? rai::process_result::old : rai::process_result::progress; // Have we seen this block before? (Harmless) - if (result.code == rai::process_result::progress) + result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Harmless) + if (result.code == nano::process_result::progress) { auto previous (ledger.store.block_get (transaction, block_a.hashables.previous)); - result.code = previous != nullptr ? rai::process_result::progress : rai::process_result::gap_previous; // Have we seen the previous block already? (Harmless) - if (result.code == rai::process_result::progress) + result.code = previous != nullptr ? nano::process_result::progress : nano::process_result::gap_previous; // Have we seen the previous block already? (Harmless) + if (result.code == nano::process_result::progress) { - result.code = block_a.valid_predecessor (*previous) ? rai::process_result::progress : rai::process_result::block_position; - if (result.code == rai::process_result::progress) + result.code = block_a.valid_predecessor (*previous) ? nano::process_result::progress : nano::process_result::block_position; + if (result.code == nano::process_result::progress) { auto account (ledger.store.frontier_get (transaction, block_a.hashables.previous)); - result.code = account.is_zero () ? rai::process_result::fork : rai::process_result::progress; - if (result.code == rai::process_result::progress) + result.code = account.is_zero () ? nano::process_result::fork : nano::process_result::progress; + if (result.code == nano::process_result::progress) { - rai::account_info info; + nano::account_info info; auto latest_error (ledger.store.account_get (transaction, account, info)); assert (!latest_error); assert (info.head == block_a.hashables.previous); - result.code = validate_message (account, hash, block_a.signature) ? rai::process_result::bad_signature : rai::process_result::progress; // Is this block signed correctly (Malformed) - if (result.code == rai::process_result::progress) + result.code = validate_message (account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Malformed) + if (result.code == nano::process_result::progress) { ledger.store.block_put (transaction, hash, block_a); auto balance (ledger.balance (transaction, block_a.hashables.previous)); @@ -422,7 +422,7 @@ void ledger_processor::change_block (rai::change_block const & block_a) ledger.store.frontier_put (transaction, hash, account); result.account = account; result.amount = 0; - ledger.stats.inc (rai::stat::type::ledger, rai::stat::detail::change); + ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::change); } } } @@ -430,45 +430,45 @@ void ledger_processor::change_block (rai::change_block const & block_a) } } -void ledger_processor::send_block (rai::send_block const & block_a) +void ledger_processor::send_block (nano::send_block const & block_a) { auto hash (block_a.hash ()); auto existing (ledger.store.block_exists (transaction, block_a.type (), hash)); - result.code = existing ? rai::process_result::old : rai::process_result::progress; // Have we seen this block before? (Harmless) - if (result.code == rai::process_result::progress) + result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Harmless) + if (result.code == nano::process_result::progress) { auto previous (ledger.store.block_get (transaction, block_a.hashables.previous)); - result.code = previous != nullptr ? rai::process_result::progress : rai::process_result::gap_previous; // Have we seen the previous block already? (Harmless) - if (result.code == rai::process_result::progress) + result.code = previous != nullptr ? nano::process_result::progress : nano::process_result::gap_previous; // Have we seen the previous block already? (Harmless) + if (result.code == nano::process_result::progress) { - result.code = block_a.valid_predecessor (*previous) ? rai::process_result::progress : rai::process_result::block_position; - if (result.code == rai::process_result::progress) + result.code = block_a.valid_predecessor (*previous) ? nano::process_result::progress : nano::process_result::block_position; + if (result.code == nano::process_result::progress) { auto account (ledger.store.frontier_get (transaction, block_a.hashables.previous)); - result.code = account.is_zero () ? rai::process_result::fork : rai::process_result::progress; - if (result.code == rai::process_result::progress) + result.code = account.is_zero () ? nano::process_result::fork : nano::process_result::progress; + if (result.code == nano::process_result::progress) { - result.code = validate_message (account, hash, block_a.signature) ? rai::process_result::bad_signature : rai::process_result::progress; // Is this block signed correctly (Malformed) - if (result.code == rai::process_result::progress) + result.code = validate_message (account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is this block signed correctly (Malformed) + if (result.code == nano::process_result::progress) { - rai::account_info info; + nano::account_info info; auto latest_error (ledger.store.account_get (transaction, account, info)); assert (!latest_error); assert (info.head == block_a.hashables.previous); - result.code = info.balance.number () >= block_a.hashables.balance.number () ? rai::process_result::progress : rai::process_result::negative_spend; // Is this trying to spend a negative amount (Malicious) - if (result.code == rai::process_result::progress) + result.code = info.balance.number () >= block_a.hashables.balance.number () ? nano::process_result::progress : nano::process_result::negative_spend; // Is this trying to spend a negative amount (Malicious) + if (result.code == nano::process_result::progress) { auto amount (info.balance.number () - block_a.hashables.balance.number ()); ledger.store.representation_add (transaction, info.rep_block, 0 - amount); ledger.store.block_put (transaction, hash, block_a); ledger.change_latest (transaction, account, hash, info.rep_block, block_a.hashables.balance, info.block_count + 1); - ledger.store.pending_put (transaction, rai::pending_key (block_a.hashables.destination, hash), { account, amount, rai::epoch::epoch_0 }); + ledger.store.pending_put (transaction, nano::pending_key (block_a.hashables.destination, hash), { account, amount, nano::epoch::epoch_0 }); ledger.store.frontier_del (transaction, block_a.hashables.previous); ledger.store.frontier_put (transaction, hash, account); result.account = account; result.amount = amount; result.pending_account = block_a.hashables.destination; - ledger.stats.inc (rai::stat::type::ledger, rai::stat::detail::send); + ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::send); } } } @@ -477,45 +477,45 @@ void ledger_processor::send_block (rai::send_block const & block_a) } } -void ledger_processor::receive_block (rai::receive_block const & block_a) +void ledger_processor::receive_block (nano::receive_block const & block_a) { auto hash (block_a.hash ()); auto existing (ledger.store.block_exists (transaction, block_a.type (), hash)); - result.code = existing ? rai::process_result::old : rai::process_result::progress; // Have we seen this block already? (Harmless) - if (result.code == rai::process_result::progress) + result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block already? (Harmless) + if (result.code == nano::process_result::progress) { auto previous (ledger.store.block_get (transaction, block_a.hashables.previous)); - result.code = previous != nullptr ? rai::process_result::progress : rai::process_result::gap_previous; - if (result.code == rai::process_result::progress) + result.code = previous != nullptr ? nano::process_result::progress : nano::process_result::gap_previous; + if (result.code == nano::process_result::progress) { - result.code = block_a.valid_predecessor (*previous) ? rai::process_result::progress : rai::process_result::block_position; - if (result.code == rai::process_result::progress) + result.code = block_a.valid_predecessor (*previous) ? nano::process_result::progress : nano::process_result::block_position; + if (result.code == nano::process_result::progress) { - result.code = (ledger.store.block_exists (transaction, rai::block_type::send, block_a.hashables.source) || ledger.store.block_exists (transaction, rai::block_type::state, block_a.hashables.source)) ? rai::process_result::progress : rai::process_result::gap_source; // Have we seen the source block already? (Harmless) - if (result.code == rai::process_result::progress) + result.code = (ledger.store.block_exists (transaction, nano::block_type::send, block_a.hashables.source) || ledger.store.block_exists (transaction, nano::block_type::state, block_a.hashables.source)) ? nano::process_result::progress : nano::process_result::gap_source; // Have we seen the source block already? (Harmless) + if (result.code == nano::process_result::progress) { auto account (ledger.store.frontier_get (transaction, block_a.hashables.previous)); - result.code = account.is_zero () ? rai::process_result::gap_previous : rai::process_result::progress; //Have we seen the previous block? No entries for account at all (Harmless) - if (result.code == rai::process_result::progress) + result.code = account.is_zero () ? nano::process_result::gap_previous : nano::process_result::progress; //Have we seen the previous block? No entries for account at all (Harmless) + if (result.code == nano::process_result::progress) { - result.code = rai::validate_message (account, hash, block_a.signature) ? rai::process_result::bad_signature : rai::process_result::progress; // Is the signature valid (Malformed) - if (result.code == rai::process_result::progress) + result.code = nano::validate_message (account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is the signature valid (Malformed) + if (result.code == nano::process_result::progress) { - rai::account_info info; + nano::account_info info; ledger.store.account_get (transaction, account, info); - result.code = info.head == block_a.hashables.previous ? rai::process_result::progress : rai::process_result::gap_previous; // Block doesn't immediately follow latest block (Harmless) - if (result.code == rai::process_result::progress) + result.code = info.head == block_a.hashables.previous ? nano::process_result::progress : nano::process_result::gap_previous; // Block doesn't immediately follow latest block (Harmless) + if (result.code == nano::process_result::progress) { - rai::pending_key key (account, block_a.hashables.source); - rai::pending_info pending; - result.code = ledger.store.pending_get (transaction, key, pending) ? rai::process_result::unreceivable : rai::process_result::progress; // Has this source already been received (Malformed) - if (result.code == rai::process_result::progress) + nano::pending_key key (account, block_a.hashables.source); + nano::pending_info pending; + result.code = ledger.store.pending_get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed) + if (result.code == nano::process_result::progress) { - result.code = pending.epoch == rai::epoch::epoch_0 ? rai::process_result::progress : rai::process_result::unreceivable; // Are we receiving a state-only send? (Malformed) - if (result.code == rai::process_result::progress) + result.code = pending.epoch == nano::epoch::epoch_0 ? nano::process_result::progress : nano::process_result::unreceivable; // Are we receiving a state-only send? (Malformed) + if (result.code == nano::process_result::progress) { auto new_balance (info.balance.number () + pending.amount.number ()); - rai::account_info source_info; + nano::account_info source_info; auto error (ledger.store.account_get (transaction, pending.source, source_info)); assert (!error); ledger.store.pending_del (transaction, key); @@ -526,7 +526,7 @@ void ledger_processor::receive_block (rai::receive_block const & block_a) ledger.store.frontier_put (transaction, hash, account); result.account = account; result.amount = pending.amount; - ledger.stats.inc (rai::stat::type::ledger, rai::stat::detail::receive); + ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::receive); } } } @@ -534,7 +534,7 @@ void ledger_processor::receive_block (rai::receive_block const & block_a) } else { - result.code = ledger.store.block_exists (transaction, block_a.hashables.previous) ? rai::process_result::fork : rai::process_result::gap_previous; // If we have the block but it's not the latest we have a signed fork (Malicious) + result.code = ledger.store.block_exists (transaction, block_a.hashables.previous) ? nano::process_result::fork : nano::process_result::gap_previous; // If we have the block but it's not the latest we have a signed fork (Malicious) } } } @@ -542,36 +542,36 @@ void ledger_processor::receive_block (rai::receive_block const & block_a) } } -void ledger_processor::open_block (rai::open_block const & block_a) +void ledger_processor::open_block (nano::open_block const & block_a) { auto hash (block_a.hash ()); auto existing (ledger.store.block_exists (transaction, block_a.type (), hash)); - result.code = existing ? rai::process_result::old : rai::process_result::progress; // Have we seen this block already? (Harmless) - if (result.code == rai::process_result::progress) + result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block already? (Harmless) + if (result.code == nano::process_result::progress) { - auto source_missing (!ledger.store.block_exists (transaction, rai::block_type::send, block_a.hashables.source) && !ledger.store.block_exists (transaction, rai::block_type::state, block_a.hashables.source)); - result.code = source_missing ? rai::process_result::gap_source : rai::process_result::progress; // Have we seen the source block? (Harmless) - if (result.code == rai::process_result::progress) + auto source_missing (!ledger.store.block_exists (transaction, nano::block_type::send, block_a.hashables.source) && !ledger.store.block_exists (transaction, nano::block_type::state, block_a.hashables.source)); + result.code = source_missing ? nano::process_result::gap_source : nano::process_result::progress; // Have we seen the source block? (Harmless) + if (result.code == nano::process_result::progress) { - result.code = rai::validate_message (block_a.hashables.account, hash, block_a.signature) ? rai::process_result::bad_signature : rai::process_result::progress; // Is the signature valid (Malformed) - if (result.code == rai::process_result::progress) + result.code = nano::validate_message (block_a.hashables.account, hash, block_a.signature) ? nano::process_result::bad_signature : nano::process_result::progress; // Is the signature valid (Malformed) + if (result.code == nano::process_result::progress) { - rai::account_info info; - result.code = ledger.store.account_get (transaction, block_a.hashables.account, info) ? rai::process_result::progress : rai::process_result::fork; // Has this account already been opened? (Malicious) - if (result.code == rai::process_result::progress) + nano::account_info info; + result.code = ledger.store.account_get (transaction, block_a.hashables.account, info) ? nano::process_result::progress : nano::process_result::fork; // Has this account already been opened? (Malicious) + if (result.code == nano::process_result::progress) { - rai::pending_key key (block_a.hashables.account, block_a.hashables.source); - rai::pending_info pending; - result.code = ledger.store.pending_get (transaction, key, pending) ? rai::process_result::unreceivable : rai::process_result::progress; // Has this source already been received (Malformed) - if (result.code == rai::process_result::progress) + nano::pending_key key (block_a.hashables.account, block_a.hashables.source); + nano::pending_info pending; + result.code = ledger.store.pending_get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed) + if (result.code == nano::process_result::progress) { - result.code = block_a.hashables.account == rai::burn_account ? rai::process_result::opened_burn_account : rai::process_result::progress; // Is it burning 0 account? (Malicious) - if (result.code == rai::process_result::progress) + result.code = block_a.hashables.account == nano::burn_account ? nano::process_result::opened_burn_account : nano::process_result::progress; // Is it burning 0 account? (Malicious) + if (result.code == nano::process_result::progress) { - result.code = pending.epoch == rai::epoch::epoch_0 ? rai::process_result::progress : rai::process_result::unreceivable; // Are we receiving a state-only send? (Malformed) - if (result.code == rai::process_result::progress) + result.code = pending.epoch == nano::epoch::epoch_0 ? nano::process_result::progress : nano::process_result::unreceivable; // Are we receiving a state-only send? (Malformed) + if (result.code == nano::process_result::progress) { - rai::account_info source_info; + nano::account_info source_info; auto error (ledger.store.account_get (transaction, pending.source, source_info)); assert (!error); ledger.store.pending_del (transaction, key); @@ -581,7 +581,7 @@ void ledger_processor::open_block (rai::open_block const & block_a) ledger.store.frontier_put (transaction, hash, block_a.hashables.account); result.account = block_a.hashables.account; result.amount = pending.amount; - ledger.stats.inc (rai::stat::type::ledger, rai::stat::detail::open); + ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::open); } } } @@ -591,7 +591,7 @@ void ledger_processor::open_block (rai::open_block const & block_a) } } -ledger_processor::ledger_processor (rai::ledger & ledger_a, rai::transaction const & transaction_a, bool valid_signature_a) : +ledger_processor::ledger_processor (nano::ledger & ledger_a, nano::transaction const & transaction_a, bool valid_signature_a) : ledger (ledger_a), transaction (transaction_a), valid_signature (valid_signature_a) @@ -599,19 +599,19 @@ valid_signature (valid_signature_a) } } // namespace -size_t rai::shared_ptr_block_hash::operator() (std::shared_ptr const & block_a) const +size_t nano::shared_ptr_block_hash::operator() (std::shared_ptr const & block_a) const { auto hash (block_a->hash ()); auto result (static_cast (hash.qwords[0])); return result; } -bool rai::shared_ptr_block_hash::operator() (std::shared_ptr const & lhs, std::shared_ptr const & rhs) const +bool nano::shared_ptr_block_hash::operator() (std::shared_ptr const & lhs, std::shared_ptr const & rhs) const { return lhs->hash () == rhs->hash (); } -rai::ledger::ledger (rai::block_store & store_a, rai::stat & stat_a, rai::uint256_union const & epoch_link_a, rai::account const & epoch_signer_a) : +nano::ledger::ledger (nano::block_store & store_a, nano::stat & stat_a, nano::uint256_union const & epoch_link_a, nano::account const & epoch_signer_a) : store (store_a), stats (stat_a), check_bootstrap_weights (true), @@ -621,17 +621,17 @@ epoch_signer (epoch_signer_a) } // Balance for account containing hash -rai::uint128_t rai::ledger::balance (rai::transaction const & transaction_a, rai::block_hash const & hash_a) +nano::uint128_t nano::ledger::balance (nano::transaction const & transaction_a, nano::block_hash const & hash_a) { - rai::summation_visitor visitor (transaction_a, store); + nano::summation_visitor visitor (transaction_a, store); return visitor.compute_balance (hash_a); } // Balance for an account by account number -rai::uint128_t rai::ledger::account_balance (rai::transaction const & transaction_a, rai::account const & account_a) +nano::uint128_t nano::ledger::account_balance (nano::transaction const & transaction_a, nano::account const & account_a) { - rai::uint128_t result (0); - rai::account_info info; + nano::uint128_t result (0); + nano::account_info info; auto none (store.account_get (transaction_a, account_a, info)); if (!none) { @@ -640,64 +640,64 @@ rai::uint128_t rai::ledger::account_balance (rai::transaction const & transactio return result; } -rai::uint128_t rai::ledger::account_pending (rai::transaction const & transaction_a, rai::account const & account_a) +nano::uint128_t nano::ledger::account_pending (nano::transaction const & transaction_a, nano::account const & account_a) { - rai::uint128_t result (0); - rai::account end (account_a.number () + 1); - for (auto i (store.pending_v0_begin (transaction_a, rai::pending_key (account_a, 0))), n (store.pending_v0_begin (transaction_a, rai::pending_key (end, 0))); i != n; ++i) + nano::uint128_t result (0); + nano::account end (account_a.number () + 1); + for (auto i (store.pending_v0_begin (transaction_a, nano::pending_key (account_a, 0))), n (store.pending_v0_begin (transaction_a, nano::pending_key (end, 0))); i != n; ++i) { - rai::pending_info info (i->second); + nano::pending_info info (i->second); result += info.amount.number (); } - for (auto i (store.pending_v1_begin (transaction_a, rai::pending_key (account_a, 0))), n (store.pending_v1_begin (transaction_a, rai::pending_key (end, 0))); i != n; ++i) + for (auto i (store.pending_v1_begin (transaction_a, nano::pending_key (account_a, 0))), n (store.pending_v1_begin (transaction_a, nano::pending_key (end, 0))); i != n; ++i) { - rai::pending_info info (i->second); + nano::pending_info info (i->second); result += info.amount.number (); } return result; } -rai::process_return rai::ledger::process (rai::transaction const & transaction_a, rai::block const & block_a, bool valid_signature) +nano::process_return nano::ledger::process (nano::transaction const & transaction_a, nano::block const & block_a, bool valid_signature) { ledger_processor processor (*this, transaction_a, valid_signature); block_a.visit (processor); return processor.result; } -rai::block_hash rai::ledger::representative (rai::transaction const & transaction_a, rai::block_hash const & hash_a) +nano::block_hash nano::ledger::representative (nano::transaction const & transaction_a, nano::block_hash const & hash_a) { auto result (representative_calculated (transaction_a, hash_a)); assert (result.is_zero () || store.block_exists (transaction_a, result)); return result; } -rai::block_hash rai::ledger::representative_calculated (rai::transaction const & transaction_a, rai::block_hash const & hash_a) +nano::block_hash nano::ledger::representative_calculated (nano::transaction const & transaction_a, nano::block_hash const & hash_a) { representative_visitor visitor (transaction_a, store); visitor.compute (hash_a); return visitor.result; } -bool rai::ledger::block_exists (rai::block_hash const & hash_a) +bool nano::ledger::block_exists (nano::block_hash const & hash_a) { auto transaction (store.tx_begin_read ()); auto result (store.block_exists (transaction, hash_a)); return result; } -bool rai::ledger::block_exists (rai::block_type type, rai::block_hash const & hash_a) +bool nano::ledger::block_exists (nano::block_type type, nano::block_hash const & hash_a) { auto transaction (store.tx_begin_read ()); auto result (store.block_exists (transaction, type, hash_a)); return result; } -std::string rai::ledger::block_text (char const * hash_a) +std::string nano::ledger::block_text (char const * hash_a) { - return block_text (rai::block_hash (hash_a)); + return block_text (nano::block_hash (hash_a)); } -std::string rai::ledger::block_text (rai::block_hash const & hash_a) +std::string nano::ledger::block_text (nano::block_hash const & hash_a) { std::string result; auto transaction (store.tx_begin_read ()); @@ -709,10 +709,10 @@ std::string rai::ledger::block_text (rai::block_hash const & hash_a) return result; } -bool rai::ledger::is_send (rai::transaction const & transaction_a, rai::state_block const & block_a) +bool nano::ledger::is_send (nano::transaction const & transaction_a, nano::state_block const & block_a) { bool result (false); - rai::block_hash previous (block_a.hashables.previous); + nano::block_hash previous (block_a.hashables.previous); if (!previous.is_zero ()) { if (block_a.hashables.balance < balance (transaction_a, previous)) @@ -723,11 +723,11 @@ bool rai::ledger::is_send (rai::transaction const & transaction_a, rai::state_bl return result; } -rai::block_hash rai::ledger::block_destination (rai::transaction const & transaction_a, rai::block const & block_a) +nano::block_hash nano::ledger::block_destination (nano::transaction const & transaction_a, nano::block const & block_a) { - rai::block_hash result (0); - rai::send_block const * send_block (dynamic_cast (&block_a)); - rai::state_block const * state_block (dynamic_cast (&block_a)); + nano::block_hash result (0); + nano::send_block const * send_block (dynamic_cast (&block_a)); + nano::state_block const * state_block (dynamic_cast (&block_a)); if (send_block != nullptr) { result = send_block->hashables.destination; @@ -739,7 +739,7 @@ rai::block_hash rai::ledger::block_destination (rai::transaction const & transac return result; } -rai::block_hash rai::ledger::block_source (rai::transaction const & transaction_a, rai::block const & block_a) +nano::block_hash nano::ledger::block_source (nano::transaction const & transaction_a, nano::block const & block_a) { /* * block_source() requires that the previous block of the block @@ -750,8 +750,8 @@ rai::block_hash rai::ledger::block_source (rai::transaction const & transaction_ // If block_a.source () is nonzero, then we have our source. // However, universal blocks will always return zero. - rai::block_hash result (block_a.source ()); - rai::state_block const * state_block (dynamic_cast (&block_a)); + nano::block_hash result (block_a.source ()); + nano::state_block const * state_block (dynamic_cast (&block_a)); if (state_block != nullptr && !is_send (transaction_a, *state_block)) { result = state_block->hashables.link; @@ -760,7 +760,7 @@ rai::block_hash rai::ledger::block_source (rai::transaction const & transaction_ } // Vote weight of an account -rai::uint128_t rai::ledger::weight (rai::transaction const & transaction_a, rai::account const & account_a) +nano::uint128_t nano::ledger::weight (nano::transaction const & transaction_a, nano::account const & account_a) { if (check_bootstrap_weights.load ()) { @@ -782,12 +782,12 @@ rai::uint128_t rai::ledger::weight (rai::transaction const & transaction_a, rai: } // Rollback blocks until `block_a' doesn't exist -void rai::ledger::rollback (rai::transaction const & transaction_a, rai::block_hash const & block_a) +void nano::ledger::rollback (nano::transaction const & transaction_a, nano::block_hash const & block_a) { assert (store.block_exists (transaction_a, block_a)); auto account_l (account (transaction_a, block_a)); rollback_visitor rollback (transaction_a, *this); - rai::account_info info; + nano::account_info info; while (store.block_exists (transaction_a, block_a)) { auto latest_error (store.account_get (transaction_a, account_l, info)); @@ -798,15 +798,15 @@ void rai::ledger::rollback (rai::transaction const & transaction_a, rai::block_h } // Return account containing hash -rai::account rai::ledger::account (rai::transaction const & transaction_a, rai::block_hash const & hash_a) +nano::account nano::ledger::account (nano::transaction const & transaction_a, nano::block_hash const & hash_a) { - rai::account result; + nano::account result; auto hash (hash_a); - rai::block_hash successor (1); - rai::block_info block_info; + nano::block_hash successor (1); + nano::block_info block_info; auto block (store.block_get (transaction_a, hash)); assert (block); - while (!successor.is_zero () && block->type () != rai::block_type::state && store.block_info_get (transaction_a, successor, block_info)) + while (!successor.is_zero () && block->type () != nano::block_type::state && store.block_info_get (transaction_a, successor, block_info)) { successor = store.block_successor (transaction_a, hash); if (!successor.is_zero ()) @@ -815,9 +815,9 @@ rai::account rai::ledger::account (rai::transaction const & transaction_a, rai:: block = store.block_get (transaction_a, hash); } } - if (block->type () == rai::block_type::state) + if (block->type () == nano::block_type::state) { - auto state_block (dynamic_cast (block.get ())); + auto state_block (dynamic_cast (block.get ())); result = state_block->hashables.account; } else if (successor.is_zero ()) @@ -833,26 +833,26 @@ rai::account rai::ledger::account (rai::transaction const & transaction_a, rai:: } // Return amount decrease or increase for block -rai::uint128_t rai::ledger::amount (rai::transaction const & transaction_a, rai::block_hash const & hash_a) +nano::uint128_t nano::ledger::amount (nano::transaction const & transaction_a, nano::block_hash const & hash_a) { summation_visitor amount (transaction_a, store); return amount.compute_amount (hash_a); } // Return latest block for account -rai::block_hash rai::ledger::latest (rai::transaction const & transaction_a, rai::account const & account_a) +nano::block_hash nano::ledger::latest (nano::transaction const & transaction_a, nano::account const & account_a) { - rai::account_info info; + nano::account_info info; auto latest_error (store.account_get (transaction_a, account_a, info)); return latest_error ? 0 : info.head; } // Return latest root for account, account number of there are no blocks for this account. -rai::block_hash rai::ledger::latest_root (rai::transaction const & transaction_a, rai::account const & account_a) +nano::block_hash nano::ledger::latest_root (nano::transaction const & transaction_a, nano::account const & account_a) { - rai::account_info info; + nano::account_info info; auto latest_error (store.account_get (transaction_a, account_a, info)); - rai::block_hash result; + nano::block_hash result; if (latest_error) { result = account_a; @@ -864,15 +864,15 @@ rai::block_hash rai::ledger::latest_root (rai::transaction const & transaction_a return result; } -rai::checksum rai::ledger::checksum (rai::transaction const & transaction_a, rai::account const & begin_a, rai::account const & end_a) +nano::checksum nano::ledger::checksum (nano::transaction const & transaction_a, nano::account const & begin_a, nano::account const & end_a) { - rai::checksum result; + nano::checksum result; auto error (store.checksum_get (transaction_a, 0, 0, result)); assert (!error); return result; } -void rai::ledger::dump_account_chain (rai::account const & account_a) +void nano::ledger::dump_account_chain (nano::account const & account_a) { auto transaction (store.tx_begin_read ()); auto hash (latest (transaction, account_a)); @@ -885,33 +885,33 @@ void rai::ledger::dump_account_chain (rai::account const & account_a) } } -class block_fit_visitor : public rai::block_visitor +class block_fit_visitor : public nano::block_visitor { public: - block_fit_visitor (rai::ledger & ledger_a, rai::transaction const & transaction_a) : + block_fit_visitor (nano::ledger & ledger_a, nano::transaction const & transaction_a) : ledger (ledger_a), transaction (transaction_a), result (false) { } - void send_block (rai::send_block const & block_a) override + void send_block (nano::send_block const & block_a) override { result = ledger.store.block_exists (transaction, block_a.previous ()); } - void receive_block (rai::receive_block const & block_a) override + void receive_block (nano::receive_block const & block_a) override { result = ledger.store.block_exists (transaction, block_a.previous ()); result &= ledger.store.block_exists (transaction, block_a.source ()); } - void open_block (rai::open_block const & block_a) override + void open_block (nano::open_block const & block_a) override { result = ledger.store.block_exists (transaction, block_a.source ()); } - void change_block (rai::change_block const & block_a) override + void change_block (nano::change_block const & block_a) override { result = ledger.store.block_exists (transaction, block_a.previous ()); } - void state_block (rai::state_block const & block_a) override + void state_block (nano::state_block const & block_a) override { result = block_a.previous ().is_zero () || ledger.store.block_exists (transaction, block_a.previous ()); if (result && !ledger.is_send (transaction, block_a)) @@ -919,35 +919,35 @@ public: result &= ledger.store.block_exists (transaction, block_a.hashables.link) || block_a.hashables.link.is_zero () || ledger.is_epoch_link (block_a.hashables.link); } } - rai::ledger & ledger; - rai::transaction const & transaction; + nano::ledger & ledger; + nano::transaction const & transaction; bool result; }; -bool rai::ledger::could_fit (rai::transaction const & transaction_a, rai::block const & block_a) +bool nano::ledger::could_fit (nano::transaction const & transaction_a, nano::block const & block_a) { block_fit_visitor visitor (*this, transaction_a); block_a.visit (visitor); return visitor.result; } -bool rai::ledger::is_epoch_link (rai::uint256_union const & link_a) +bool nano::ledger::is_epoch_link (nano::uint256_union const & link_a) { return link_a == epoch_link; } -void rai::ledger::checksum_update (rai::transaction const & transaction_a, rai::block_hash const & hash_a) +void nano::ledger::checksum_update (nano::transaction const & transaction_a, nano::block_hash const & hash_a) { - rai::checksum value; + nano::checksum value; auto error (store.checksum_get (transaction_a, 0, 0, value)); assert (!error); value ^= hash_a; store.checksum_put (transaction_a, 0, 0, value); } -void rai::ledger::change_latest (rai::transaction const & transaction_a, rai::account const & account_a, rai::block_hash const & hash_a, rai::block_hash const & rep_block_a, rai::amount const & balance_a, uint64_t block_count_a, bool is_state, rai::epoch epoch_a) +void nano::ledger::change_latest (nano::transaction const & transaction_a, nano::account const & account_a, nano::block_hash const & hash_a, nano::block_hash const & rep_block_a, nano::amount const & balance_a, uint64_t block_count_a, bool is_state, nano::epoch epoch_a) { - rai::account_info info; + nano::account_info info; auto exists (!store.account_get (transaction_a, account_a, info)); if (exists) { @@ -963,7 +963,7 @@ void rai::ledger::change_latest (rai::transaction const & transaction_a, rai::ac info.head = hash_a; info.rep_block = rep_block_a; info.balance = balance_a; - info.modified = rai::seconds_since_epoch (); + info.modified = nano::seconds_since_epoch (); info.block_count = block_count_a; if (exists && info.epoch != epoch_a) { @@ -974,7 +974,7 @@ void rai::ledger::change_latest (rai::transaction const & transaction_a, rai::ac store.account_put (transaction_a, account_a, info); if (!(block_count_a % store.block_info_max) && !is_state) { - rai::block_info block_info; + nano::block_info block_info; block_info.account = account_a; block_info.balance = balance_a; store.block_info_put (transaction_a, hash_a, block_info); @@ -987,12 +987,12 @@ void rai::ledger::change_latest (rai::transaction const & transaction_a, rai::ac } } -std::shared_ptr rai::ledger::successor (rai::transaction const & transaction_a, rai::uint256_union const & root_a) +std::shared_ptr nano::ledger::successor (nano::transaction const & transaction_a, nano::uint256_union const & root_a) { - rai::block_hash successor (0); + nano::block_hash successor (0); if (store.account_exists (transaction_a, root_a)) { - rai::account_info info; + nano::account_info info; auto error (store.account_get (transaction_a, root_a, info)); assert (!error); successor = info.open_block; @@ -1001,7 +1001,7 @@ std::shared_ptr rai::ledger::successor (rai::transaction const & tra { successor = store.block_successor (transaction_a, root_a); } - std::shared_ptr result; + std::shared_ptr result; if (!successor.is_zero ()) { result = store.block_get (transaction_a, successor); @@ -1010,7 +1010,7 @@ std::shared_ptr rai::ledger::successor (rai::transaction const & tra return result; } -std::shared_ptr rai::ledger::forked_block (rai::transaction const & transaction_a, rai::block const & block_a) +std::shared_ptr nano::ledger::forked_block (nano::transaction const & transaction_a, nano::block const & block_a) { assert (!store.block_exists (transaction_a, block_a.type (), block_a.hash ())); auto root (block_a.root ()); @@ -1018,7 +1018,7 @@ std::shared_ptr rai::ledger::forked_block (rai::transaction const & auto result (store.block_get (transaction_a, store.block_successor (transaction_a, root))); if (result == nullptr) { - rai::account_info info; + nano::account_info info; auto error (store.account_get (transaction_a, root, info)); assert (!error); result = store.block_get (transaction_a, info.open_block); diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp new file mode 100644 index 00000000..4d0838e0 --- /dev/null +++ b/nano/secure/ledger.hpp @@ -0,0 +1,57 @@ +#pragma once + +#include + +namespace nano +{ +class block_store; +class stat; + +class shared_ptr_block_hash +{ +public: + size_t operator() (std::shared_ptr const &) const; + bool operator() (std::shared_ptr const &, std::shared_ptr const &) const; +}; +using tally_t = std::map, std::greater>; +class ledger +{ +public: + ledger (nano::block_store &, nano::stat &, nano::uint256_union const & = 1, nano::account const & = 0); + nano::account account (nano::transaction const &, nano::block_hash const &); + nano::uint128_t amount (nano::transaction const &, nano::block_hash const &); + nano::uint128_t balance (nano::transaction const &, nano::block_hash const &); + nano::uint128_t account_balance (nano::transaction const &, nano::account const &); + nano::uint128_t account_pending (nano::transaction const &, nano::account const &); + nano::uint128_t weight (nano::transaction const &, nano::account const &); + std::shared_ptr successor (nano::transaction const &, nano::block_hash const &); + std::shared_ptr forked_block (nano::transaction const &, nano::block const &); + nano::block_hash latest (nano::transaction const &, nano::account const &); + nano::block_hash latest_root (nano::transaction const &, nano::account const &); + nano::block_hash representative (nano::transaction const &, nano::block_hash const &); + nano::block_hash representative_calculated (nano::transaction const &, nano::block_hash const &); + bool block_exists (nano::block_hash const &); + bool block_exists (nano::block_type, nano::block_hash const &); + std::string block_text (char const *); + std::string block_text (nano::block_hash const &); + bool is_send (nano::transaction const &, nano::state_block const &); + nano::block_hash block_destination (nano::transaction const &, nano::block const &); + nano::block_hash block_source (nano::transaction const &, nano::block const &); + nano::process_return process (nano::transaction const &, nano::block const &, bool = false); + void rollback (nano::transaction const &, nano::block_hash const &); + void change_latest (nano::transaction const &, nano::account const &, nano::block_hash const &, nano::account const &, nano::uint128_union const &, uint64_t, bool = false, nano::epoch = nano::epoch::epoch_0); + void checksum_update (nano::transaction const &, nano::block_hash const &); + nano::checksum checksum (nano::transaction const &, nano::account const &, nano::account const &); + void dump_account_chain (nano::account const &); + bool could_fit (nano::transaction const &, nano::block const &); + bool is_epoch_link (nano::uint256_union const &); + static nano::uint128_t const unit; + nano::block_store & store; + nano::stat & stats; + std::unordered_map bootstrap_weights; + uint64_t bootstrap_weight_max_blocks; + std::atomic check_bootstrap_weights; + nano::uint256_union epoch_link; + nano::account epoch_signer; +}; +}; diff --git a/rai/secure/plat/osx/working.mm b/nano/secure/plat/osx/working.mm similarity index 87% rename from rai/secure/plat/osx/working.mm rename to nano/secure/plat/osx/working.mm index e18b60a5..77cdb007 100644 --- a/rai/secure/plat/osx/working.mm +++ b/nano/secure/plat/osx/working.mm @@ -1,8 +1,8 @@ -#include +#include #include -namespace rai +namespace nano { boost::filesystem::path app_path () { diff --git a/rai/secure/plat/posix/working.cpp b/nano/secure/plat/posix/working.cpp similarity index 81% rename from rai/secure/plat/posix/working.cpp rename to nano/secure/plat/posix/working.cpp index 28984239..d19d07cd 100644 --- a/rai/secure/plat/posix/working.cpp +++ b/nano/secure/plat/posix/working.cpp @@ -1,9 +1,9 @@ -#include +#include #include #include -namespace rai +namespace nano { boost::filesystem::path app_path () { diff --git a/rai/secure/plat/windows/working.cpp b/nano/secure/plat/windows/working.cpp similarity index 85% rename from rai/secure/plat/windows/working.cpp rename to nano/secure/plat/windows/working.cpp index 810ec269..860e27bd 100644 --- a/rai/secure/plat/windows/working.cpp +++ b/nano/secure/plat/windows/working.cpp @@ -1,8 +1,8 @@ -#include +#include #include -namespace rai +namespace nano { boost::filesystem::path app_path () { diff --git a/rai/secure/utility.cpp b/nano/secure/utility.cpp similarity index 61% rename from rai/secure/utility.cpp rename to nano/secure/utility.cpp index a91d18e2..890009b6 100644 --- a/rai/secure/utility.cpp +++ b/nano/secure/utility.cpp @@ -1,36 +1,36 @@ -#include +#include -#include -#include +#include +#include static std::vector all_unique_paths; -boost::filesystem::path rai::working_path () +boost::filesystem::path nano::working_path () { - auto result (rai::app_path ()); - switch (rai::rai_network) + auto result (nano::app_path ()); + switch (nano::nano_network) { - case rai::rai_networks::rai_test_network: - result /= "RaiBlocksTest"; + case nano::nano_networks::nano_test_network: + result /= "NanoTest"; break; - case rai::rai_networks::rai_beta_network: - result /= "RaiBlocksBeta"; + case nano::nano_networks::nano_beta_network: + result /= "NanoBeta"; break; - case rai::rai_networks::rai_live_network: - result /= "RaiBlocks"; + case nano::nano_networks::nano_live_network: + result /= "Nano"; break; } return result; } -boost::filesystem::path rai::unique_path () +boost::filesystem::path nano::unique_path () { auto result (working_path () / boost::filesystem::unique_path ()); all_unique_paths.push_back (result); return result; } -std::vector rai::remove_temporary_directories () +std::vector nano::remove_temporary_directories () { for (auto & path : all_unique_paths) { @@ -53,7 +53,7 @@ std::vector rai::remove_temporary_directories () return all_unique_paths; } -void rai::open_or_create (std::fstream & stream_a, std::string const & path_a) +void nano::open_or_create (std::fstream & stream_a, std::string const & path_a) { stream_a.open (path_a, std::ios_base::in); if (stream_a.fail ()) diff --git a/rai/secure/utility.hpp b/nano/secure/utility.hpp similarity index 94% rename from rai/secure/utility.hpp rename to nano/secure/utility.hpp index 8ea021da..ff3f44d1 100644 --- a/rai/secure/utility.hpp +++ b/nano/secure/utility.hpp @@ -12,11 +12,11 @@ #include -#include -#include -#include +#include +#include +#include -namespace rai +namespace nano { using bufferstream = boost::iostreams::stream_buffer>; using vectorstream = boost::iostreams::stream_buffer>>; @@ -61,7 +61,7 @@ template bool fetch_object (T & object, boost::filesystem::path const & path_a, std::fstream & stream_a) { bool error (false); - rai::open_or_create (stream_a, path_a.string ()); + nano::open_or_create (stream_a, path_a.string ()); if (!stream_a.fail ()) { boost::property_tree::ptree tree; diff --git a/rai/secure/versioning.cpp b/nano/secure/versioning.cpp similarity index 55% rename from rai/secure/versioning.cpp rename to nano/secure/versioning.cpp index e7c4823f..81273433 100644 --- a/rai/secure/versioning.cpp +++ b/nano/secure/versioning.cpp @@ -1,6 +1,6 @@ -#include +#include -rai::account_info_v1::account_info_v1 () : +nano::account_info_v1::account_info_v1 () : head (0), rep_block (0), balance (0), @@ -8,14 +8,14 @@ modified (0) { } -rai::account_info_v1::account_info_v1 (MDB_val const & val_a) +nano::account_info_v1::account_info_v1 (MDB_val const & val_a) { assert (val_a.mv_size == sizeof (*this)); static_assert (sizeof (head) + sizeof (rep_block) + sizeof (balance) + sizeof (modified) == sizeof (*this), "Class not packed"); std::copy (reinterpret_cast (val_a.mv_data), reinterpret_cast (val_a.mv_data) + sizeof (*this), reinterpret_cast (this)); } -rai::account_info_v1::account_info_v1 (rai::block_hash const & head_a, rai::block_hash const & rep_block_a, rai::amount const & balance_a, uint64_t modified_a) : +nano::account_info_v1::account_info_v1 (nano::block_hash const & head_a, nano::block_hash const & rep_block_a, nano::amount const & balance_a, uint64_t modified_a) : head (head_a), rep_block (rep_block_a), balance (balance_a), @@ -23,7 +23,7 @@ modified (modified_a) { } -void rai::account_info_v1::serialize (rai::stream & stream_a) const +void nano::account_info_v1::serialize (nano::stream & stream_a) const { write (stream_a, head.bytes); write (stream_a, rep_block.bytes); @@ -31,7 +31,7 @@ void rai::account_info_v1::serialize (rai::stream & stream_a) const write (stream_a, modified); } -bool rai::account_info_v1::deserialize (rai::stream & stream_a) +bool nano::account_info_v1::deserialize (nano::stream & stream_a) { auto error (read (stream_a, head.bytes)); if (!error) @@ -49,64 +49,64 @@ bool rai::account_info_v1::deserialize (rai::stream & stream_a) return error; } -rai::mdb_val rai::account_info_v1::val () const +nano::mdb_val nano::account_info_v1::val () const { - return rai::mdb_val (sizeof (*this), const_cast (this)); + return nano::mdb_val (sizeof (*this), const_cast (this)); } -rai::pending_info_v3::pending_info_v3 () : +nano::pending_info_v3::pending_info_v3 () : source (0), amount (0), destination (0) { } -rai::pending_info_v3::pending_info_v3 (MDB_val const & val_a) +nano::pending_info_v3::pending_info_v3 (MDB_val const & val_a) { assert (val_a.mv_size == sizeof (*this)); static_assert (sizeof (source) + sizeof (amount) + sizeof (destination) == sizeof (*this), "Packed class"); std::copy (reinterpret_cast (val_a.mv_data), reinterpret_cast (val_a.mv_data) + sizeof (*this), reinterpret_cast (this)); } -rai::pending_info_v3::pending_info_v3 (rai::account const & source_a, rai::amount const & amount_a, rai::account const & destination_a) : +nano::pending_info_v3::pending_info_v3 (nano::account const & source_a, nano::amount const & amount_a, nano::account const & destination_a) : source (source_a), amount (amount_a), destination (destination_a) { } -void rai::pending_info_v3::serialize (rai::stream & stream_a) const +void nano::pending_info_v3::serialize (nano::stream & stream_a) const { - rai::write (stream_a, source.bytes); - rai::write (stream_a, amount.bytes); - rai::write (stream_a, destination.bytes); + nano::write (stream_a, source.bytes); + nano::write (stream_a, amount.bytes); + nano::write (stream_a, destination.bytes); } -bool rai::pending_info_v3::deserialize (rai::stream & stream_a) +bool nano::pending_info_v3::deserialize (nano::stream & stream_a) { - auto error (rai::read (stream_a, source.bytes)); + auto error (nano::read (stream_a, source.bytes)); if (!error) { - error = rai::read (stream_a, amount.bytes); + error = nano::read (stream_a, amount.bytes); if (!error) { - error = rai::read (stream_a, destination.bytes); + error = nano::read (stream_a, destination.bytes); } } return error; } -bool rai::pending_info_v3::operator== (rai::pending_info_v3 const & other_a) const +bool nano::pending_info_v3::operator== (nano::pending_info_v3 const & other_a) const { return source == other_a.source && amount == other_a.amount && destination == other_a.destination; } -rai::mdb_val rai::pending_info_v3::val () const +nano::mdb_val nano::pending_info_v3::val () const { - return rai::mdb_val (sizeof (*this), const_cast (this)); + return nano::mdb_val (sizeof (*this), const_cast (this)); } -rai::account_info_v5::account_info_v5 () : +nano::account_info_v5::account_info_v5 () : head (0), rep_block (0), open_block (0), @@ -115,14 +115,14 @@ modified (0) { } -rai::account_info_v5::account_info_v5 (MDB_val const & val_a) +nano::account_info_v5::account_info_v5 (MDB_val const & val_a) { assert (val_a.mv_size == sizeof (*this)); static_assert (sizeof (head) + sizeof (rep_block) + sizeof (open_block) + sizeof (balance) + sizeof (modified) == sizeof (*this), "Class not packed"); std::copy (reinterpret_cast (val_a.mv_data), reinterpret_cast (val_a.mv_data) + sizeof (*this), reinterpret_cast (this)); } -rai::account_info_v5::account_info_v5 (rai::block_hash const & head_a, rai::block_hash const & rep_block_a, rai::block_hash const & open_block_a, rai::amount const & balance_a, uint64_t modified_a) : +nano::account_info_v5::account_info_v5 (nano::block_hash const & head_a, nano::block_hash const & rep_block_a, nano::block_hash const & open_block_a, nano::amount const & balance_a, uint64_t modified_a) : head (head_a), rep_block (rep_block_a), open_block (open_block_a), @@ -131,7 +131,7 @@ modified (modified_a) { } -void rai::account_info_v5::serialize (rai::stream & stream_a) const +void nano::account_info_v5::serialize (nano::stream & stream_a) const { write (stream_a, head.bytes); write (stream_a, rep_block.bytes); @@ -140,7 +140,7 @@ void rai::account_info_v5::serialize (rai::stream & stream_a) const write (stream_a, modified); } -bool rai::account_info_v5::deserialize (rai::stream & stream_a) +bool nano::account_info_v5::deserialize (nano::stream & stream_a) { auto error (read (stream_a, head.bytes)); if (!error) @@ -162,7 +162,7 @@ bool rai::account_info_v5::deserialize (rai::stream & stream_a) return error; } -rai::mdb_val rai::account_info_v5::val () const +nano::mdb_val nano::account_info_v5::val () const { - return rai::mdb_val (sizeof (*this), const_cast (this)); + return nano::mdb_val (sizeof (*this), const_cast (this)); } diff --git a/nano/secure/versioning.hpp b/nano/secure/versioning.hpp new file mode 100644 index 00000000..9455b21a --- /dev/null +++ b/nano/secure/versioning.hpp @@ -0,0 +1,55 @@ +#pragma once + +#include +#include +#include + +namespace nano +{ +class account_info_v1 +{ +public: + account_info_v1 (); + account_info_v1 (MDB_val const &); + account_info_v1 (nano::account_info_v1 const &) = default; + account_info_v1 (nano::block_hash const &, nano::block_hash const &, nano::amount const &, uint64_t); + void serialize (nano::stream &) const; + bool deserialize (nano::stream &); + nano::mdb_val val () const; + nano::block_hash head; + nano::block_hash rep_block; + nano::amount balance; + uint64_t modified; +}; +class pending_info_v3 +{ +public: + pending_info_v3 (); + pending_info_v3 (MDB_val const &); + pending_info_v3 (nano::account const &, nano::amount const &, nano::account const &); + void serialize (nano::stream &) const; + bool deserialize (nano::stream &); + bool operator== (nano::pending_info_v3 const &) const; + nano::mdb_val val () const; + nano::account source; + nano::amount amount; + nano::account destination; +}; +// Latest information about an account +class account_info_v5 +{ +public: + account_info_v5 (); + account_info_v5 (MDB_val const &); + account_info_v5 (nano::account_info_v5 const &) = default; + account_info_v5 (nano::block_hash const &, nano::block_hash const &, nano::block_hash const &, nano::amount const &, uint64_t); + void serialize (nano::stream &) const; + bool deserialize (nano::stream &); + nano::mdb_val val () const; + nano::block_hash head; + nano::block_hash rep_block; + nano::block_hash open_block; + nano::amount balance; + uint64_t modified; +}; +} diff --git a/rai/slow_test/CMakeLists.txt b/nano/slow_test/CMakeLists.txt similarity index 100% rename from rai/slow_test/CMakeLists.txt rename to nano/slow_test/CMakeLists.txt diff --git a/rai/slow_test/node.cpp b/nano/slow_test/node.cpp similarity index 65% rename from rai/slow_test/node.cpp rename to nano/slow_test/node.cpp index 96cbd883..32a0e3ea 100644 --- a/rai/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -1,12 +1,12 @@ #include -#include +#include #include TEST (system, generate_mass_activity) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); size_t count (20); system.generate_mass_activity (count, *system.nodes[0]); size_t accounts (0); @@ -19,9 +19,9 @@ TEST (system, generate_mass_activity) TEST (system, generate_mass_activity_long) { - rai::system system (24000, 1); - rai::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); size_t count (1000000000); system.generate_mass_activity (count, *system.nodes[0]); size_t accounts (0); @@ -38,14 +38,14 @@ TEST (system, receive_while_synchronizing) { std::vector threads; { - rai::system system (24000, 1); - rai::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); + nano::system system (24000, 1); + nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); size_t count (1000); system.generate_mass_activity (count, *system.nodes[0]); - rai::keypair key; - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); + nano::keypair key; + nano::node_init init1; + auto node1 (std::make_shared (init1, system.io_ctx, 24001, nano::unique_path (), system.alarm, system.logging, system.work)); ASSERT_FALSE (init1.error ()); node1->network.send_keepalive (system.nodes[0]->network.endpoint ()); auto wallet (node1->wallets.create (1)); @@ -53,7 +53,7 @@ TEST (system, receive_while_synchronizing) node1->start (); system.nodes.push_back (node1); system.alarm.add (std::chrono::steady_clock::now () + std::chrono::milliseconds (200), ([&system, &key]() { - auto hash (system.wallet (0)->send_sync (rai::test_genesis_key.pub, key.pub, system.nodes[0]->config.receive_minimum.number ())); + auto hash (system.wallet (0)->send_sync (nano::test_genesis_key.pub, key.pub, system.nodes[0]->config.receive_minimum.number ())); auto transaction (system.nodes[0]->store.tx_begin ()); auto block (system.nodes[0]->store.block_get (transaction, hash)); std::string block_text; @@ -76,29 +76,29 @@ TEST (system, receive_while_synchronizing) TEST (ledger, deep_account_compute) { bool init (false); - rai::mdb_store store (init, rai::unique_path ()); + nano::mdb_store store (init, nano::unique_path ()); ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; + nano::stat stats; + nano::ledger ledger (store, stats); + nano::genesis genesis; auto transaction (store.tx_begin (true)); store.initialize (transaction, genesis); - rai::keypair key; - auto balance (rai::genesis_amount - 1); - rai::send_block send (genesis.hash (), key.pub, balance, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send).code); - rai::open_block open (send.hash (), rai::test_genesis_key.pub, key.pub, key.prv, key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open).code); + nano::keypair key; + auto balance (nano::genesis_amount - 1); + nano::send_block send (genesis.hash (), key.pub, balance, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); + nano::open_block open (send.hash (), nano::test_genesis_key.pub, key.pub, key.prv, key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); auto sprevious (send.hash ()); auto rprevious (open.hash ()); for (auto i (0), n (100000); i != n; ++i) { balance -= 1; - rai::send_block send (sprevious, key.pub, balance, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send).code); + nano::send_block send (sprevious, key.pub, balance, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); sprevious = send.hash (); - rai::receive_block receive (rprevious, send.hash (), key.prv, key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, receive).code); + nano::receive_block receive (rprevious, send.hash (), key.prv, key.pub, 0); + ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code); rprevious = receive.hash (); if (i % 100 == 0) { @@ -115,20 +115,20 @@ TEST (wallet, multithreaded_send) { std::vector threads; { - rai::system system (24000, 1); - rai::keypair key; + nano::system system (24000, 1); + nano::keypair key; auto wallet_l (system.wallet (0)); - wallet_l->insert_adhoc (rai::test_genesis_key.prv); + wallet_l->insert_adhoc (nano::test_genesis_key.prv); for (auto i (0); i < 20; ++i) { threads.push_back (boost::thread ([wallet_l, &key]() { for (auto i (0); i < 1000; ++i) { - wallet_l->send_action (rai::test_genesis_key.pub, key.pub, 1000); + wallet_l->send_action (nano::test_genesis_key.pub, key.pub, 1000); } })); } - while (system.nodes[0]->balance (rai::test_genesis_key.pub) != (rai::genesis_amount - 20 * 1000 * 1000)) + while (system.nodes[0]->balance (nano::test_genesis_key.pub) != (nano::genesis_amount - 20 * 1000 * 1000)) { system.poll (); } @@ -141,7 +141,7 @@ TEST (wallet, multithreaded_send) TEST (store, load) { - rai::system system (24000, 1); + nano::system system (24000, 1); std::vector threads; for (auto i (0); i < 100; ++i) { @@ -151,9 +151,9 @@ TEST (store, load) auto transaction (system.nodes[0]->store.tx_begin (true)); for (auto j (0); j != 10; ++j) { - rai::block_hash hash; - rai::random_pool.GenerateBlock (hash.bytes.data (), hash.bytes.size ()); - system.nodes[0]->store.account_put (transaction, hash, rai::account_info ()); + nano::block_hash hash; + nano::random_pool.GenerateBlock (hash.bytes.data (), hash.bytes.size ()); + system.nodes[0]->store.account_put (transaction, hash, nano::account_info ()); } } })); @@ -166,26 +166,26 @@ TEST (store, load) TEST (node, fork_storm) { - rai::system system (24000, 64); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto previous (system.nodes[0]->latest (rai::test_genesis_key.pub)); - auto balance (system.nodes[0]->balance (rai::test_genesis_key.pub)); + nano::system system (24000, 64); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + auto previous (system.nodes[0]->latest (nano::test_genesis_key.pub)); + auto balance (system.nodes[0]->balance (nano::test_genesis_key.pub)); ASSERT_FALSE (previous.is_zero ()); for (auto j (0); j != system.nodes.size (); ++j) { balance -= 1; - rai::keypair key; - rai::send_block send (previous, key.pub, balance, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); + nano::keypair key; + nano::send_block send (previous, key.pub, balance, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0); previous = send.hash (); for (auto i (0); i != system.nodes.size (); ++i) { auto send_result (system.nodes[i]->process (send)); - ASSERT_EQ (rai::process_result::progress, send_result.code); - rai::keypair rep; - auto open (std::make_shared (previous, rep.pub, key.pub, key.prv, key.pub, 0)); + ASSERT_EQ (nano::process_result::progress, send_result.code); + nano::keypair rep; + auto open (std::make_shared (previous, rep.pub, key.pub, key.prv, key.pub, 0)); system.nodes[i]->work_generate_blocking (*open); auto open_result (system.nodes[i]->process (*open)); - ASSERT_EQ (rai::process_result::progress, open_result.code); + ASSERT_EQ (nano::process_result::progress, open_result.code); auto transaction (system.nodes[i]->store.tx_begin ()); system.nodes[i]->network.republish_block (open); } @@ -199,7 +199,7 @@ TEST (node, fork_storm) { empty = 0; single = 0; - std::for_each (system.nodes.begin (), system.nodes.end (), [&](std::shared_ptr const & node_a) { + std::for_each (system.nodes.begin (), system.nodes.end (), [&](std::shared_ptr const & node_a) { if (node_a->active.roots.empty ()) { ++empty; @@ -323,7 +323,7 @@ TEST (broadcast, sqrt_broadcast_simulate) for (auto j (0); j != broadcast_count; ++j) { ++message_count; - auto entry (rai::random_pool.GenerateWord32 (0, node_count - 1)); + auto entry (nano::random_pool.GenerateWord32 (0, node_count - 1)); switch (nodes[entry]) { case 0: @@ -355,10 +355,10 @@ TEST (broadcast, sqrt_broadcast_simulate) TEST (peer_container, random_set) { auto loopback (boost::asio::ip::address_v6::loopback ()); - rai::peer_container container (rai::endpoint (loopback, 24000)); + nano::peer_container container (nano::endpoint (loopback, 24000)); for (auto i (0); i < 200; ++i) { - container.contacted (rai::endpoint (loopback, 24001 + i), 0); + container.contacted (nano::endpoint (loopback, 24001 + i), 0); } auto old (std::chrono::steady_clock::now ()); for (auto i (0); i < 10000; ++i) @@ -380,9 +380,9 @@ TEST (peer_container, random_set) TEST (store, unchecked_load) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto & node (*system.nodes[0]); - auto block (std::make_shared (0, 0, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + auto block (std::make_shared (0, 0, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); for (auto i (0); i < 1000000; ++i) { auto transaction (node.store.tx_begin (true)); @@ -395,27 +395,27 @@ TEST (store, unchecked_load) TEST (store, vote_load) { - rai::system system (24000, 1); + nano::system system (24000, 1); auto & node (*system.nodes[0]); - auto block (std::make_shared (0, 0, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); + auto block (std::make_shared (0, 0, 0, nano::test_genesis_key.prv, nano::test_genesis_key.pub, 0)); for (auto i (0); i < 1000000; ++i) { - auto vote (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, i, block)); + auto vote (std::make_shared (nano::test_genesis_key.pub, nano::test_genesis_key.prv, i, block)); node.vote_processor.vote (vote, system.nodes[0]->network.endpoint ()); } } TEST (node, mass_vote_by_hash) { - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::genesis genesis; - rai::block_hash previous (genesis.hash ()); - rai::keypair key; - std::vector> blocks; + nano::system system (24000, 1); + system.wallet (0)->insert_adhoc (nano::test_genesis_key.prv); + nano::genesis genesis; + nano::block_hash previous (genesis.hash ()); + nano::keypair key; + std::vector> blocks; for (auto i (0); i < 10000; ++i) { - auto block (std::make_shared (rai::test_genesis_key.pub, previous, rai::test_genesis_key.pub, rai::genesis_amount - (i + 1) * rai::Gxrb_ratio, key.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (previous))); + auto block (std::make_shared (nano::test_genesis_key.pub, previous, nano::test_genesis_key.pub, nano::genesis_amount - (i + 1) * nano::Gxrb_ratio, key.pub, nano::test_genesis_key.prv, nano::test_genesis_key.pub, system.work.generate (previous))); previous = block->hash (); blocks.push_back (block); } diff --git a/rai/core_test/conflicts.cpp b/rai/core_test/conflicts.cpp deleted file mode 100644 index 0d930691..00000000 --- a/rai/core_test/conflicts.cpp +++ /dev/null @@ -1,175 +0,0 @@ -#include -#include - -TEST (conflicts, start_stop) -{ - rai::system system (24000, 1); - auto & node1 (*system.nodes[0]); - rai::genesis genesis; - rai::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*send1); - ASSERT_EQ (rai::process_result::progress, node1.process (*send1).code); - ASSERT_EQ (0, node1.active.roots.size ()); - node1.active.start (send1); - ASSERT_EQ (1, node1.active.roots.size ()); - auto root1 (send1->root ()); - auto existing1 (node1.active.roots.find (root1)); - ASSERT_NE (node1.active.roots.end (), existing1); - auto votes1 (existing1->election); - ASSERT_NE (nullptr, votes1); - ASSERT_EQ (1, votes1->last_votes.size ()); -} - -TEST (conflicts, add_existing) -{ - rai::system system (24000, 1); - auto & node1 (*system.nodes[0]); - rai::genesis genesis; - rai::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*send1); - ASSERT_EQ (rai::process_result::progress, node1.process (*send1).code); - node1.active.start (send1); - rai::keypair key2; - auto send2 (std::make_shared (genesis.hash (), key2.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.active.start (send2); - ASSERT_EQ (1, node1.active.roots.size ()); - auto vote1 (std::make_shared (key2.pub, key2.prv, 0, send2)); - node1.active.vote (vote1); - ASSERT_EQ (1, node1.active.roots.size ()); - auto votes1 (node1.active.roots.find (send2->root ())->election); - ASSERT_NE (nullptr, votes1); - ASSERT_EQ (2, votes1->last_votes.size ()); - ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (key2.pub)); -} - -TEST (conflicts, add_two) -{ - rai::system system (24000, 1); - auto & node1 (*system.nodes[0]); - rai::genesis genesis; - rai::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*send1); - ASSERT_EQ (rai::process_result::progress, node1.process (*send1).code); - node1.active.start (send1); - rai::keypair key2; - auto send2 (std::make_shared (send1->hash (), key2.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*send2); - ASSERT_EQ (rai::process_result::progress, node1.process (*send2).code); - node1.active.start (send2); - ASSERT_EQ (2, node1.active.roots.size ()); -} - -TEST (vote_uniquer, null) -{ - rai::block_uniquer block_uniquer; - rai::vote_uniquer uniquer (block_uniquer); - ASSERT_EQ (nullptr, uniquer.unique (nullptr)); -} - -// Show that an identical vote can be uniqued -TEST (vote_uniquer, same_vote) -{ - rai::block_uniquer block_uniquer; - rai::vote_uniquer uniquer (block_uniquer); - rai::keypair key; - auto vote1 (std::make_shared (key.pub, key.prv, 0, std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0))); - auto vote2 (std::make_shared (*vote1)); - ASSERT_EQ (vote1, uniquer.unique (vote1)); - ASSERT_EQ (vote1, uniquer.unique (vote2)); -} - -// Show that a different vote for the same block will have the block uniqued -TEST (vote_uniquer, same_block) -{ - rai::block_uniquer block_uniquer; - rai::vote_uniquer uniquer (block_uniquer); - rai::keypair key1; - rai::keypair key2; - auto block1 (std::make_shared (0, 0, 0, 0, 0, key1.prv, key1.pub, 0)); - auto block2 (std::make_shared (*block1)); - auto vote1 (std::make_shared (key1.pub, key1.prv, 0, block1)); - auto vote2 (std::make_shared (key1.pub, key1.prv, 0, block2)); - ASSERT_EQ (vote1, uniquer.unique (vote1)); - ASSERT_EQ (vote2, uniquer.unique (vote2)); - ASSERT_NE (vote1, vote2); - ASSERT_EQ (boost::get> (vote1->blocks[0]), boost::get> (vote2->blocks[0])); -} - -TEST (vote_uniquer, vbh_one) -{ - rai::block_uniquer block_uniquer; - rai::vote_uniquer uniquer (block_uniquer); - rai::keypair key; - auto block (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0)); - std::vector hashes; - hashes.push_back (block->hash ()); - auto vote1 (std::make_shared (key.pub, key.prv, 0, hashes)); - auto vote2 (std::make_shared (*vote1)); - ASSERT_EQ (vote1, uniquer.unique (vote1)); - ASSERT_EQ (vote1, uniquer.unique (vote2)); -} - -TEST (vote_uniquer, vbh_two) -{ - rai::block_uniquer block_uniquer; - rai::vote_uniquer uniquer (block_uniquer); - rai::keypair key; - auto block1 (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0)); - std::vector hashes1; - hashes1.push_back (block1->hash ()); - auto block2 (std::make_shared (1, 0, 0, 0, 0, key.prv, key.pub, 0)); - std::vector hashes2; - hashes2.push_back (block2->hash ()); - auto vote1 (std::make_shared (key.pub, key.prv, 0, hashes1)); - auto vote2 (std::make_shared (key.pub, key.prv, 0, hashes2)); - ASSERT_EQ (vote1, uniquer.unique (vote1)); - ASSERT_EQ (vote2, uniquer.unique (vote2)); -} - -TEST (vote_uniquer, cleanup) -{ - rai::block_uniquer block_uniquer; - rai::vote_uniquer uniquer (block_uniquer); - rai::keypair key; - auto vote1 (std::make_shared (key.pub, key.prv, 0, std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0))); - auto vote2 (std::make_shared (key.pub, key.prv, 1, std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0))); - auto vote3 (uniquer.unique (vote1)); - auto vote4 (uniquer.unique (vote2)); - vote2.reset (); - vote4.reset (); - ASSERT_EQ (2, uniquer.size ()); - auto iterations (0); - while (uniquer.size () == 2) - { - auto vote5 (uniquer.unique (vote1)); - ASSERT_LT (iterations++, 200); - } -} - -TEST (conflicts, reprioritize) -{ - rai::system system (24000, 1); - auto & node1 (*system.nodes[0]); - rai::genesis genesis; - rai::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*send1); - uint64_t difficulty1; - rai::work_validate (*send1, &difficulty1); - node1.process_active (send1); - node1.block_processor.flush (); - auto existing1 (node1.active.roots.find (send1->root ())); - ASSERT_NE (node1.active.roots.end (), existing1); - ASSERT_EQ (difficulty1, existing1->difficulty); - node1.work_generate_blocking (*send1, difficulty1); - uint64_t difficulty2; - rai::work_validate (*send1, &difficulty2); - node1.process_active (send1); - node1.block_processor.flush (); - auto existing2 (node1.active.roots.find (send1->root ())); - ASSERT_NE (node1.active.roots.end (), existing2); - ASSERT_EQ (difficulty2, existing2->difficulty); -} diff --git a/rai/core_test/ledger.cpp b/rai/core_test/ledger.cpp deleted file mode 100644 index 50785a66..00000000 --- a/rai/core_test/ledger.cpp +++ /dev/null @@ -1,2434 +0,0 @@ -#include -#include -#include -#include -#include -#include - -using namespace std::chrono_literals; - -// Init returns an error if it can't open files at the path -TEST (ledger, store_error) -{ - bool init (false); - rai::mdb_store store (init, boost::filesystem::path ("///")); - ASSERT_FALSE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); -} - -// Ledger can be initialized and returns a basic query for an empty account -TEST (ledger, empty) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::account account; - auto transaction (store.tx_begin ()); - auto balance (ledger.account_balance (transaction, account)); - ASSERT_TRUE (balance.is_zero ()); -} - -// Genesis account should have the max balance on empty initialization -TEST (ledger, genesis_balance) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - auto balance (ledger.account_balance (transaction, rai::genesis_account)); - ASSERT_EQ (rai::genesis_amount, balance); - auto amount (ledger.amount (transaction, rai::genesis_account)); - ASSERT_EQ (rai::genesis_amount, amount); - rai::account_info info; - ASSERT_FALSE (store.account_get (transaction, rai::genesis_account, info)); - // Frontier time should have been updated when genesis balance was added - ASSERT_GE (rai::seconds_since_epoch (), info.modified); - ASSERT_LT (rai::seconds_since_epoch () - info.modified, 10); -} - -// Make sure the checksum is the same when ledger reloaded -TEST (ledger, checksum_persistence) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::uint256_union checksum1; - rai::uint256_union max; - max.qwords[0] = 0; - max.qwords[0] = ~max.qwords[0]; - max.qwords[1] = 0; - max.qwords[1] = ~max.qwords[1]; - max.qwords[2] = 0; - max.qwords[2] = ~max.qwords[2]; - max.qwords[3] = 0; - max.qwords[3] = ~max.qwords[3]; - rai::stat stats; - auto transaction (store.tx_begin (true)); - { - rai::ledger ledger (store, stats); - rai::genesis genesis; - store.initialize (transaction, genesis); - checksum1 = ledger.checksum (transaction, 0, max); - } - rai::ledger ledger (store, stats); - ASSERT_EQ (checksum1, ledger.checksum (transaction, 0, max)); -} - -// All nodes in the system should agree on the genesis balance -TEST (system, system_genesis) -{ - rai::system system (24000, 2); - for (auto & i : system.nodes) - { - auto transaction (i->store.tx_begin ()); - ASSERT_EQ (rai::genesis_amount, i->ledger.account_balance (transaction, rai::genesis_account)); - } -} - -// Create a send block and publish it. -TEST (ledger, process_send) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - auto transaction (store.tx_begin (true)); - rai::genesis genesis; - store.initialize (transaction, genesis); - rai::account_info info1; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info1)); - rai::keypair key2; - rai::send_block send (info1.head, key2.pub, 50, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::block_hash hash1 (send.hash ()); - ASSERT_EQ (rai::test_genesis_key.pub, store.frontier_get (transaction, info1.head)); - ASSERT_EQ (1, info1.block_count); - // This was a valid block, it should progress. - auto return1 (ledger.process (transaction, send)); - ASSERT_EQ (rai::genesis_amount - 50, ledger.amount (transaction, hash1)); - ASSERT_TRUE (store.frontier_get (transaction, info1.head).is_zero ()); - ASSERT_EQ (rai::test_genesis_key.pub, store.frontier_get (transaction, hash1)); - ASSERT_EQ (rai::process_result::progress, return1.code); - ASSERT_EQ (rai::test_genesis_key.pub, return1.account); - ASSERT_EQ (rai::genesis_amount - 50, return1.amount.number ()); - ASSERT_EQ (50, ledger.account_balance (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (rai::genesis_amount - 50, ledger.account_pending (transaction, key2.pub)); - rai::account_info info2; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info2)); - ASSERT_EQ (2, info2.block_count); - auto latest6 (store.block_get (transaction, info2.head)); - ASSERT_NE (nullptr, latest6); - auto latest7 (dynamic_cast (latest6.get ())); - ASSERT_NE (nullptr, latest7); - ASSERT_EQ (send, *latest7); - // Create an open block opening an account accepting the send we just created - rai::open_block open (hash1, key2.pub, key2.pub, key2.prv, key2.pub, 0); - rai::block_hash hash2 (open.hash ()); - // This was a valid block, it should progress. - auto return2 (ledger.process (transaction, open)); - ASSERT_EQ (rai::genesis_amount - 50, ledger.amount (transaction, hash2)); - ASSERT_EQ (rai::process_result::progress, return2.code); - ASSERT_EQ (key2.pub, return2.account); - ASSERT_EQ (rai::genesis_amount - 50, return2.amount.number ()); - ASSERT_EQ (key2.pub, store.frontier_get (transaction, hash2)); - ASSERT_EQ (rai::genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); - ASSERT_EQ (0, ledger.account_pending (transaction, key2.pub)); - ASSERT_EQ (50, ledger.weight (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (rai::genesis_amount - 50, ledger.weight (transaction, key2.pub)); - rai::account_info info3; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info3)); - auto latest2 (store.block_get (transaction, info3.head)); - ASSERT_NE (nullptr, latest2); - auto latest3 (dynamic_cast (latest2.get ())); - ASSERT_NE (nullptr, latest3); - ASSERT_EQ (send, *latest3); - rai::account_info info4; - ASSERT_FALSE (store.account_get (transaction, key2.pub, info4)); - auto latest4 (store.block_get (transaction, info4.head)); - ASSERT_NE (nullptr, latest4); - auto latest5 (dynamic_cast (latest4.get ())); - ASSERT_NE (nullptr, latest5); - ASSERT_EQ (open, *latest5); - ledger.rollback (transaction, hash2); - ASSERT_TRUE (store.frontier_get (transaction, hash2).is_zero ()); - rai::account_info info5; - ASSERT_TRUE (ledger.store.account_get (transaction, key2.pub, info5)); - rai::pending_info pending1; - ASSERT_FALSE (ledger.store.pending_get (transaction, rai::pending_key (key2.pub, hash1), pending1)); - ASSERT_EQ (rai::test_genesis_key.pub, pending1.source); - ASSERT_EQ (rai::genesis_amount - 50, pending1.amount.number ()); - ASSERT_EQ (0, ledger.account_balance (transaction, key2.pub)); - ASSERT_EQ (rai::genesis_amount - 50, ledger.account_pending (transaction, key2.pub)); - ASSERT_EQ (50, ledger.account_balance (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (50, ledger.weight (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - rai::account_info info6; - ASSERT_FALSE (ledger.store.account_get (transaction, rai::test_genesis_key.pub, info6)); - ASSERT_EQ (hash1, info6.head); - ledger.rollback (transaction, info6.head); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (rai::test_genesis_key.pub, store.frontier_get (transaction, info1.head)); - ASSERT_TRUE (store.frontier_get (transaction, hash1).is_zero ()); - rai::account_info info7; - ASSERT_FALSE (ledger.store.account_get (transaction, rai::test_genesis_key.pub, info7)); - ASSERT_EQ (1, info7.block_count); - ASSERT_EQ (info1.head, info7.head); - rai::pending_info pending2; - ASSERT_TRUE (ledger.store.pending_get (transaction, rai::pending_key (key2.pub, hash1), pending2)); - ASSERT_EQ (rai::genesis_amount, ledger.account_balance (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, ledger.account_pending (transaction, key2.pub)); -} - -TEST (ledger, process_receive) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::account_info info1; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info1)); - rai::keypair key2; - rai::send_block send (info1.head, key2.pub, 50, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::block_hash hash1 (send.hash ()); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send).code); - rai::keypair key3; - rai::open_block open (hash1, key3.pub, key2.pub, key2.prv, key2.pub, 0); - rai::block_hash hash2 (open.hash ()); - auto return1 (ledger.process (transaction, open)); - ASSERT_EQ (rai::process_result::progress, return1.code); - ASSERT_EQ (key2.pub, return1.account); - ASSERT_EQ (rai::genesis_amount - 50, return1.amount.number ()); - ASSERT_EQ (rai::genesis_amount - 50, ledger.weight (transaction, key3.pub)); - rai::send_block send2 (hash1, key2.pub, 25, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::block_hash hash3 (send2.hash ()); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send2).code); - rai::receive_block receive (hash2, hash3, key2.prv, key2.pub, 0); - auto hash4 (receive.hash ()); - ASSERT_EQ (key2.pub, store.frontier_get (transaction, hash2)); - auto return2 (ledger.process (transaction, receive)); - ASSERT_EQ (25, ledger.amount (transaction, hash4)); - ASSERT_TRUE (store.frontier_get (transaction, hash2).is_zero ()); - ASSERT_EQ (key2.pub, store.frontier_get (transaction, hash4)); - ASSERT_EQ (rai::process_result::progress, return2.code); - ASSERT_EQ (key2.pub, return2.account); - ASSERT_EQ (25, return2.amount.number ()); - ASSERT_EQ (hash4, ledger.latest (transaction, key2.pub)); - ASSERT_EQ (25, ledger.account_balance (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, ledger.account_pending (transaction, key2.pub)); - ASSERT_EQ (rai::genesis_amount - 25, ledger.account_balance (transaction, key2.pub)); - ASSERT_EQ (rai::genesis_amount - 25, ledger.weight (transaction, key3.pub)); - ledger.rollback (transaction, hash4); - ASSERT_TRUE (store.block_successor (transaction, hash2).is_zero ()); - ASSERT_EQ (key2.pub, store.frontier_get (transaction, hash2)); - ASSERT_TRUE (store.frontier_get (transaction, hash4).is_zero ()); - ASSERT_EQ (25, ledger.account_balance (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (25, ledger.account_pending (transaction, key2.pub)); - ASSERT_EQ (rai::genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); - ASSERT_EQ (rai::genesis_amount - 50, ledger.weight (transaction, key3.pub)); - ASSERT_EQ (hash2, ledger.latest (transaction, key2.pub)); - rai::pending_info pending1; - ASSERT_FALSE (ledger.store.pending_get (transaction, rai::pending_key (key2.pub, hash3), pending1)); - ASSERT_EQ (rai::test_genesis_key.pub, pending1.source); - ASSERT_EQ (25, pending1.amount.number ()); -} - -TEST (ledger, rollback_receiver) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::account_info info1; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info1)); - rai::keypair key2; - rai::send_block send (info1.head, key2.pub, 50, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::block_hash hash1 (send.hash ()); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send).code); - rai::keypair key3; - rai::open_block open (hash1, key3.pub, key2.pub, key2.prv, key2.pub, 0); - rai::block_hash hash2 (open.hash ()); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open).code); - ASSERT_EQ (hash2, ledger.latest (transaction, key2.pub)); - ASSERT_EQ (50, ledger.account_balance (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (rai::genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); - ASSERT_EQ (50, ledger.weight (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (rai::genesis_amount - 50, ledger.weight (transaction, key3.pub)); - ledger.rollback (transaction, hash1); - ASSERT_EQ (rai::genesis_amount, ledger.account_balance (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, ledger.account_balance (transaction, key2.pub)); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); - rai::account_info info2; - ASSERT_TRUE (ledger.store.account_get (transaction, key2.pub, info2)); - rai::pending_info pending1; - ASSERT_TRUE (ledger.store.pending_get (transaction, rai::pending_key (key2.pub, info2.head), pending1)); -} - -TEST (ledger, rollback_representation) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key5; - rai::change_block change1 (genesis.hash (), key5.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, change1).code); - rai::keypair key3; - rai::change_block change2 (change1.hash (), key3.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, change2).code); - rai::keypair key2; - rai::send_block send1 (change2.hash (), key2.pub, 50, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::keypair key4; - rai::open_block open (send1.hash (), key4.pub, key2.pub, key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open).code); - rai::send_block send2 (send1.hash (), key2.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send2).code); - rai::receive_block receive1 (open.hash (), send2.hash (), key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_EQ (1, ledger.weight (transaction, key3.pub)); - ASSERT_EQ (rai::genesis_amount - 1, ledger.weight (transaction, key4.pub)); - rai::account_info info1; - ASSERT_FALSE (store.account_get (transaction, key2.pub, info1)); - ASSERT_EQ (open.hash (), info1.rep_block); - ledger.rollback (transaction, receive1.hash ()); - rai::account_info info2; - ASSERT_FALSE (store.account_get (transaction, key2.pub, info2)); - ASSERT_EQ (open.hash (), info2.rep_block); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (rai::genesis_amount - 50, ledger.weight (transaction, key4.pub)); - ledger.rollback (transaction, open.hash ()); - ASSERT_EQ (1, ledger.weight (transaction, key3.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key4.pub)); - ledger.rollback (transaction, send1.hash ()); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, key3.pub)); - rai::account_info info3; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info3)); - ASSERT_EQ (change2.hash (), info3.rep_block); - ledger.rollback (transaction, change2.hash ()); - rai::account_info info4; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info4)); - ASSERT_EQ (change1.hash (), info4.rep_block); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, key5.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); -} - -TEST (ledger, receive_rollback) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::send_block send (genesis.hash (), rai::test_genesis_key.pub, rai::genesis_amount - rai::Gxrb_ratio, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send).code); - rai::receive_block receive (send.hash (), send.hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, receive).code); - ledger.rollback (transaction, receive.hash ()); -} - -TEST (ledger, process_duplicate) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::account_info info1; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info1)); - rai::keypair key2; - rai::send_block send (info1.head, key2.pub, 50, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::block_hash hash1 (send.hash ()); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send).code); - ASSERT_EQ (rai::process_result::old, ledger.process (transaction, send).code); - rai::open_block open (hash1, 1, key2.pub, key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open).code); - ASSERT_EQ (rai::process_result::old, ledger.process (transaction, open).code); -} - -TEST (ledger, representative_genesis) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - auto latest (ledger.latest (transaction, rai::test_genesis_key.pub)); - ASSERT_FALSE (latest.is_zero ()); - ASSERT_EQ (genesis.open->hash (), ledger.representative (transaction, latest)); -} - -TEST (ledger, weight) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::genesis_account)); -} - -TEST (ledger, representative_change) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::keypair key2; - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - rai::account_info info1; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info1)); - rai::change_block block (info1.head, key2.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::test_genesis_key.pub, store.frontier_get (transaction, info1.head)); - auto return1 (ledger.process (transaction, block)); - ASSERT_EQ (0, ledger.amount (transaction, block.hash ())); - ASSERT_TRUE (store.frontier_get (transaction, info1.head).is_zero ()); - ASSERT_EQ (rai::test_genesis_key.pub, store.frontier_get (transaction, block.hash ())); - ASSERT_EQ (rai::process_result::progress, return1.code); - ASSERT_EQ (rai::test_genesis_key.pub, return1.account); - ASSERT_EQ (0, ledger.weight (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, key2.pub)); - rai::account_info info2; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info2)); - ASSERT_EQ (block.hash (), info2.head); - ledger.rollback (transaction, info2.head); - ASSERT_EQ (rai::test_genesis_key.pub, store.frontier_get (transaction, info1.head)); - ASSERT_TRUE (store.frontier_get (transaction, block.hash ()).is_zero ()); - rai::account_info info3; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info3)); - ASSERT_EQ (info1.head, info3.head); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); -} - -TEST (ledger, send_fork) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::keypair key2; - rai::keypair key3; - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::account_info info1; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info1)); - rai::send_block block (info1.head, key2.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block).code); - rai::send_block block2 (info1.head, key3.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::fork, ledger.process (transaction, block2).code); -} - -TEST (ledger, receive_fork) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::keypair key2; - rai::keypair key3; - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::account_info info1; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info1)); - rai::send_block block (info1.head, key2.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block).code); - rai::open_block block2 (block.hash (), key2.pub, key2.pub, key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block2).code); - rai::change_block block3 (block2.hash (), key3.pub, key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block3).code); - rai::send_block block4 (block.hash (), key2.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block4).code); - rai::receive_block block5 (block2.hash (), block4.hash (), key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::fork, ledger.process (transaction, block5).code); -} - -TEST (ledger, open_fork) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::keypair key2; - rai::keypair key3; - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::account_info info1; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info1)); - rai::send_block block (info1.head, key2.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block).code); - rai::open_block block2 (block.hash (), key2.pub, key2.pub, key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block2).code); - rai::open_block block3 (block.hash (), key3.pub, key2.pub, key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::fork, ledger.process (transaction, block3).code); -} - -TEST (ledger, checksum_single) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - rai::stat stats; - rai::ledger ledger (store, stats); - store.initialize (transaction, genesis); - store.checksum_put (transaction, 0, 0, genesis.hash ()); - ASSERT_EQ (genesis.hash (), ledger.checksum (transaction, 0, std::numeric_limits::max ())); - rai::change_block block1 (ledger.latest (transaction, rai::test_genesis_key.pub), rai::account (1), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::checksum check1 (ledger.checksum (transaction, 0, std::numeric_limits::max ())); - ASSERT_EQ (genesis.hash (), check1); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block1).code); - rai::checksum check2 (ledger.checksum (transaction, 0, std::numeric_limits::max ())); - ASSERT_EQ (block1.hash (), check2); -} - -TEST (ledger, checksum_two) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - rai::stat stats; - rai::ledger ledger (store, stats); - store.initialize (transaction, genesis); - store.checksum_put (transaction, 0, 0, genesis.hash ()); - rai::keypair key2; - rai::send_block block1 (ledger.latest (transaction, rai::test_genesis_key.pub), key2.pub, 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block1).code); - rai::checksum check1 (ledger.checksum (transaction, 0, std::numeric_limits::max ())); - rai::open_block block2 (block1.hash (), 1, key2.pub, key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block2).code); - rai::checksum check2 (ledger.checksum (transaction, 0, std::numeric_limits::max ())); - ASSERT_EQ (check1, check2 ^ block2.hash ()); -} - -TEST (ledger, DISABLED_checksum_range) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - auto transaction (store.tx_begin ()); - rai::checksum check1 (ledger.checksum (transaction, 0, std::numeric_limits::max ())); - ASSERT_TRUE (check1.is_zero ()); - rai::block_hash hash1 (42); - rai::checksum check2 (ledger.checksum (transaction, 0, 42)); - ASSERT_TRUE (check2.is_zero ()); - rai::checksum check3 (ledger.checksum (transaction, 42, std::numeric_limits::max ())); - ASSERT_EQ (hash1, check3); -} - -TEST (system, DISABLED_generate_send_existing) -{ - rai::system system (24000, 1); - rai::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair stake_preserver; - auto send_block (system.wallet (0)->send_action (rai::genesis_account, stake_preserver.pub, rai::genesis_amount / 3 * 2, true)); - rai::account_info info1; - { - auto transaction (system.wallet (0)->wallets.tx_begin ()); - ASSERT_FALSE (system.nodes[0]->store.account_get (transaction, rai::test_genesis_key.pub, info1)); - } - std::vector accounts; - accounts.push_back (rai::test_genesis_key.pub); - system.generate_send_existing (*system.nodes[0], accounts); - // Have stake_preserver receive funds after generate_send_existing so it isn't chosen as the destination - { - auto transaction (system.nodes[0]->store.tx_begin (true)); - auto open_block (std::make_shared (send_block->hash (), rai::genesis_account, stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0)); - system.nodes[0]->work_generate_blocking (*open_block); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->ledger.process (transaction, *open_block).code); - } - ASSERT_GT (system.nodes[0]->balance (stake_preserver.pub), system.nodes[0]->balance (rai::genesis_account)); - rai::account_info info2; - { - auto transaction (system.wallet (0)->wallets.tx_begin ()); - ASSERT_FALSE (system.nodes[0]->store.account_get (transaction, rai::test_genesis_key.pub, info2)); - } - ASSERT_NE (info1.head, info2.head); - system.deadline_set (15s); - while (info2.block_count < info1.block_count + 2) - { - ASSERT_NO_ERROR (system.poll ()); - auto transaction (system.wallet (0)->wallets.tx_begin ()); - ASSERT_FALSE (system.nodes[0]->store.account_get (transaction, rai::test_genesis_key.pub, info2)); - } - ASSERT_EQ (info1.block_count + 2, info2.block_count); - ASSERT_EQ (info2.balance, rai::genesis_amount / 3); - { - auto transaction (system.wallet (0)->wallets.tx_begin ()); - ASSERT_NE (system.nodes[0]->ledger.amount (transaction, info2.head), 0); - } - system.stop (); - runner.join (); -} - -TEST (system, generate_send_new) -{ - rai::system system (24000, 1); - rai::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - { - auto transaction (system.nodes[0]->store.tx_begin ()); - auto iterator1 (system.nodes[0]->store.latest_begin (transaction)); - ASSERT_NE (system.nodes[0]->store.latest_end (), iterator1); - ++iterator1; - ASSERT_EQ (system.nodes[0]->store.latest_end (), iterator1); - } - rai::keypair stake_preserver; - auto send_block (system.wallet (0)->send_action (rai::genesis_account, stake_preserver.pub, rai::genesis_amount / 3 * 2, true)); - { - auto transaction (system.nodes[0]->store.tx_begin (true)); - auto open_block (std::make_shared (send_block->hash (), rai::genesis_account, stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0)); - system.nodes[0]->work_generate_blocking (*open_block); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->ledger.process (transaction, *open_block).code); - } - ASSERT_GT (system.nodes[0]->balance (stake_preserver.pub), system.nodes[0]->balance (rai::genesis_account)); - std::vector accounts; - accounts.push_back (rai::test_genesis_key.pub); - system.generate_send_new (*system.nodes[0], accounts); - rai::account new_account (0); - { - auto transaction (system.nodes[0]->store.tx_begin ()); - auto iterator2 (system.wallet (0)->store.begin (transaction)); - if (rai::uint256_union (iterator2->first) != rai::test_genesis_key.pub) - { - new_account = rai::uint256_union (iterator2->first); - } - ++iterator2; - ASSERT_NE (system.wallet (0)->store.end (), iterator2); - if (rai::uint256_union (iterator2->first) != rai::test_genesis_key.pub) - { - new_account = rai::uint256_union (iterator2->first); - } - ++iterator2; - ASSERT_EQ (system.wallet (0)->store.end (), iterator2); - ASSERT_FALSE (new_account.is_zero ()); - } - system.deadline_set (10s); - while (system.nodes[0]->balance (new_account) == 0) - { - ASSERT_NO_ERROR (system.poll ()); - } - system.stop (); - runner.join (); -} - -TEST (ledger, representation) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - ASSERT_EQ (rai::genesis_amount, store.representation_get (transaction, rai::test_genesis_key.pub)); - rai::keypair key2; - rai::send_block block1 (genesis.hash (), key2.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block1).code); - ASSERT_EQ (rai::genesis_amount - 100, store.representation_get (transaction, rai::test_genesis_key.pub)); - rai::keypair key3; - rai::open_block block2 (block1.hash (), key3.pub, key2.pub, key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block2).code); - ASSERT_EQ (rai::genesis_amount - 100, store.representation_get (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); - ASSERT_EQ (100, store.representation_get (transaction, key3.pub)); - rai::send_block block3 (block1.hash (), key2.pub, rai::genesis_amount - 200, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block3).code); - ASSERT_EQ (rai::genesis_amount - 200, store.representation_get (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); - ASSERT_EQ (100, store.representation_get (transaction, key3.pub)); - rai::receive_block block4 (block2.hash (), block3.hash (), key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block4).code); - ASSERT_EQ (rai::genesis_amount - 200, store.representation_get (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); - ASSERT_EQ (200, store.representation_get (transaction, key3.pub)); - rai::keypair key4; - rai::change_block block5 (block4.hash (), key4.pub, key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block5).code); - ASSERT_EQ (rai::genesis_amount - 200, store.representation_get (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key3.pub)); - ASSERT_EQ (200, store.representation_get (transaction, key4.pub)); - rai::keypair key5; - rai::send_block block6 (block5.hash (), key5.pub, 100, key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block6).code); - ASSERT_EQ (rai::genesis_amount - 200, store.representation_get (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key3.pub)); - ASSERT_EQ (100, store.representation_get (transaction, key4.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key5.pub)); - rai::keypair key6; - rai::open_block block7 (block6.hash (), key6.pub, key5.pub, key5.prv, key5.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block7).code); - ASSERT_EQ (rai::genesis_amount - 200, store.representation_get (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key3.pub)); - ASSERT_EQ (100, store.representation_get (transaction, key4.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key5.pub)); - ASSERT_EQ (100, store.representation_get (transaction, key6.pub)); - rai::send_block block8 (block6.hash (), key5.pub, 0, key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block8).code); - ASSERT_EQ (rai::genesis_amount - 200, store.representation_get (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key3.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key4.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key5.pub)); - ASSERT_EQ (100, store.representation_get (transaction, key6.pub)); - rai::receive_block block9 (block7.hash (), block8.hash (), key5.prv, key5.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block9).code); - ASSERT_EQ (rai::genesis_amount - 200, store.representation_get (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key2.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key3.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key4.pub)); - ASSERT_EQ (0, store.representation_get (transaction, key5.pub)); - ASSERT_EQ (200, store.representation_get (transaction, key6.pub)); -} - -TEST (ledger, double_open) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key2; - rai::send_block send1 (genesis.hash (), key2.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::open_block open1 (send1.hash (), key2.pub, key2.pub, key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open1).code); - rai::open_block open2 (send1.hash (), rai::test_genesis_key.pub, key2.pub, key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::fork, ledger.process (transaction, open2).code); -} - -TEST (ledegr, double_receive) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key2; - rai::send_block send1 (genesis.hash (), key2.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::open_block open1 (send1.hash (), key2.pub, key2.pub, key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open1).code); - rai::receive_block receive1 (open1.hash (), send1.hash (), key2.prv, key2.pub, 0); - ASSERT_EQ (rai::process_result::unreceivable, ledger.process (transaction, receive1).code); -} - -TEST (votes, check_signature) -{ - rai::system system (24000, 1); - auto & node1 (*system.nodes[0]); - rai::genesis genesis; - rai::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*send1); - auto transaction (node1.store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, node1.ledger.process (transaction, *send1).code); - auto node_l (system.nodes[0]); - node1.active.start (send1); - auto votes1 (node1.active.roots.find (send1->root ())->election); - ASSERT_EQ (1, votes1->last_votes.size ()); - std::unique_lock lock (node1.active.mutex); - auto vote1 (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 1, send1)); - vote1->signature.bytes[0] ^= 1; - ASSERT_EQ (rai::vote_code::invalid, node1.vote_processor.vote_blocking (transaction, vote1, rai::endpoint (boost::asio::ip::address_v6 (), 0))); - vote1->signature.bytes[0] ^= 1; - ASSERT_EQ (rai::vote_code::vote, node1.vote_processor.vote_blocking (transaction, vote1, rai::endpoint (boost::asio::ip::address_v6 (), 0))); - ASSERT_EQ (rai::vote_code::replay, node1.vote_processor.vote_blocking (transaction, vote1, rai::endpoint (boost::asio::ip::address_v6 (), 0))); -} - -TEST (votes, add_one) -{ - rai::system system (24000, 1); - auto & node1 (*system.nodes[0]); - rai::genesis genesis; - rai::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*send1); - auto transaction (node1.store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, node1.ledger.process (transaction, *send1).code); - node1.active.start (send1); - auto votes1 (node1.active.roots.find (send1->root ())->election); - ASSERT_EQ (1, votes1->last_votes.size ()); - auto vote1 (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 1, send1)); - ASSERT_FALSE (node1.active.vote (vote1)); - auto vote2 (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 2, send1)); - ASSERT_FALSE (node1.active.vote (vote2)); - ASSERT_EQ (2, votes1->last_votes.size ()); - auto existing1 (votes1->last_votes.find (rai::test_genesis_key.pub)); - ASSERT_NE (votes1->last_votes.end (), existing1); - ASSERT_EQ (send1->hash (), existing1->second.hash); - auto winner (*votes1->tally (transaction).begin ()); - ASSERT_EQ (*send1, *winner.second); - ASSERT_EQ (rai::genesis_amount - 100, winner.first); -} - -TEST (votes, add_two) -{ - rai::system system (24000, 1); - auto & node1 (*system.nodes[0]); - rai::genesis genesis; - rai::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*send1); - auto transaction (node1.store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, node1.ledger.process (transaction, *send1).code); - node1.active.start (send1); - auto votes1 (node1.active.roots.find (send1->root ())->election); - auto vote1 (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 1, send1)); - ASSERT_FALSE (node1.active.vote (vote1)); - rai::keypair key2; - auto send2 (std::make_shared (genesis.hash (), key2.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - auto vote2 (std::make_shared (key2.pub, key2.prv, 1, send2)); - ASSERT_FALSE (node1.active.vote (vote2)); - ASSERT_EQ (3, votes1->last_votes.size ()); - ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (rai::test_genesis_key.pub)); - ASSERT_EQ (send1->hash (), votes1->last_votes[rai::test_genesis_key.pub].hash); - ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (key2.pub)); - ASSERT_EQ (send2->hash (), votes1->last_votes[key2.pub].hash); - auto winner (*votes1->tally (transaction).begin ()); - ASSERT_EQ (*send1, *winner.second); -} - -// Higher sequence numbers change the vote -TEST (votes, add_existing) -{ - rai::system system (24000, 1); - auto & node1 (*system.nodes[0]); - rai::genesis genesis; - rai::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, rai::genesis_amount - rai::Gxrb_ratio, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*send1); - auto transaction (node1.store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, node1.ledger.process (transaction, *send1).code); - node1.active.start (send1); - auto votes1 (node1.active.roots.find (send1->root ())->election); - auto vote1 (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 1, send1)); - ASSERT_FALSE (node1.active.vote (vote1)); - ASSERT_FALSE (node1.active.publish (send1)); - ASSERT_EQ (1, votes1->last_votes[rai::test_genesis_key.pub].sequence); - rai::keypair key2; - auto send2 (std::make_shared (genesis.hash (), key2.pub, rai::genesis_amount - rai::Gxrb_ratio, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - auto vote2 (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 2, send2)); - // Pretend we've waited the timeout - votes1->last_votes[rai::test_genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); - ASSERT_FALSE (node1.active.vote (vote2)); - ASSERT_FALSE (node1.active.publish (send2)); - ASSERT_EQ (2, votes1->last_votes[rai::test_genesis_key.pub].sequence); - // Also resend the old vote, and see if we respect the sequence number - votes1->last_votes[rai::test_genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); - ASSERT_TRUE (node1.active.vote (vote1)); - ASSERT_EQ (2, votes1->last_votes[rai::test_genesis_key.pub].sequence); - ASSERT_EQ (2, votes1->last_votes.size ()); - ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (rai::test_genesis_key.pub)); - ASSERT_EQ (send2->hash (), votes1->last_votes[rai::test_genesis_key.pub].hash); - auto winner (*votes1->tally (transaction).begin ()); - ASSERT_EQ (*send2, *winner.second); -} - -// Lower sequence numbers are ignored -TEST (votes, add_old) -{ - rai::system system (24000, 1); - auto & node1 (*system.nodes[0]); - rai::genesis genesis; - rai::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*send1); - auto transaction (node1.store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, node1.ledger.process (transaction, *send1).code); - node1.active.start (send1); - auto votes1 (node1.active.roots.find (send1->root ())->election); - auto vote1 (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 2, send1)); - std::unique_lock lock (node1.active.mutex); - node1.vote_processor.vote_blocking (transaction, vote1, node1.network.endpoint ()); - lock.unlock (); - rai::keypair key2; - auto send2 (std::make_shared (genesis.hash (), key2.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - auto vote2 (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 1, send2)); - votes1->last_votes[rai::test_genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); - lock.lock (); - node1.vote_processor.vote_blocking (transaction, vote2, node1.network.endpoint ()); - lock.unlock (); - ASSERT_EQ (2, votes1->last_votes.size ()); - ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (rai::test_genesis_key.pub)); - ASSERT_EQ (send1->hash (), votes1->last_votes[rai::test_genesis_key.pub].hash); - auto winner (*votes1->tally (transaction).begin ()); - ASSERT_EQ (*send1, *winner.second); -} - -// Lower sequence numbers are accepted for different accounts -TEST (votes, add_old_different_account) -{ - rai::system system (24000, 1); - auto & node1 (*system.nodes[0]); - rai::genesis genesis; - rai::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*send1); - auto send2 (std::make_shared (send1->hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*send2); - auto transaction (node1.store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, node1.ledger.process (transaction, *send1).code); - ASSERT_EQ (rai::process_result::progress, node1.ledger.process (transaction, *send2).code); - node1.active.start (send1); - node1.active.start (send2); - auto votes1 (node1.active.roots.find (send1->root ())->election); - auto votes2 (node1.active.roots.find (send2->root ())->election); - ASSERT_EQ (1, votes1->last_votes.size ()); - ASSERT_EQ (1, votes2->last_votes.size ()); - auto vote1 (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 2, send1)); - std::unique_lock lock (node1.active.mutex); - auto vote_result1 (node1.vote_processor.vote_blocking (transaction, vote1, node1.network.endpoint ())); - lock.unlock (); - ASSERT_EQ (rai::vote_code::vote, vote_result1); - ASSERT_EQ (2, votes1->last_votes.size ()); - ASSERT_EQ (1, votes2->last_votes.size ()); - lock.lock (); - auto vote2 (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 1, send2)); - auto vote_result2 (node1.vote_processor.vote_blocking (transaction, vote2, node1.network.endpoint ())); - lock.unlock (); - ASSERT_EQ (rai::vote_code::vote, vote_result2); - ASSERT_EQ (2, votes1->last_votes.size ()); - ASSERT_EQ (2, votes2->last_votes.size ()); - ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (rai::test_genesis_key.pub)); - ASSERT_NE (votes2->last_votes.end (), votes2->last_votes.find (rai::test_genesis_key.pub)); - ASSERT_EQ (send1->hash (), votes1->last_votes[rai::test_genesis_key.pub].hash); - ASSERT_EQ (send2->hash (), votes2->last_votes[rai::test_genesis_key.pub].hash); - auto winner1 (*votes1->tally (transaction).begin ()); - ASSERT_EQ (*send1, *winner1.second); - auto winner2 (*votes2->tally (transaction).begin ()); - ASSERT_EQ (*send2, *winner2.second); -} - -// The voting cooldown is respected -TEST (votes, add_cooldown) -{ - rai::system system (24000, 1); - auto & node1 (*system.nodes[0]); - rai::genesis genesis; - rai::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*send1); - auto transaction (node1.store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, node1.ledger.process (transaction, *send1).code); - node1.active.start (send1); - auto votes1 (node1.active.roots.find (send1->root ())->election); - auto vote1 (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 1, send1)); - std::unique_lock lock (node1.active.mutex); - node1.vote_processor.vote_blocking (transaction, vote1, node1.network.endpoint ()); - lock.unlock (); - rai::keypair key2; - auto send2 (std::make_shared (genesis.hash (), key2.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*send2); - auto vote2 (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 2, send2)); - lock.lock (); - node1.vote_processor.vote_blocking (transaction, vote2, node1.network.endpoint ()); - lock.unlock (); - ASSERT_EQ (2, votes1->last_votes.size ()); - ASSERT_NE (votes1->last_votes.end (), votes1->last_votes.find (rai::test_genesis_key.pub)); - ASSERT_EQ (send1->hash (), votes1->last_votes[rai::test_genesis_key.pub].hash); - auto winner (*votes1->tally (transaction).begin ()); - ASSERT_EQ (*send1, *winner.second); -} - -// Query for block successor -TEST (ledger, successor) -{ - rai::system system (24000, 1); - rai::keypair key1; - rai::genesis genesis; - rai::send_block send1 (genesis.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto transaction (system.nodes[0]->store.tx_begin (true)); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->ledger.process (transaction, send1).code); - ASSERT_EQ (send1, *system.nodes[0]->ledger.successor (transaction, genesis.hash ())); - ASSERT_EQ (*genesis.open, *system.nodes[0]->ledger.successor (transaction, genesis.open->root ())); - ASSERT_EQ (nullptr, system.nodes[0]->ledger.successor (transaction, 0)); -} - -TEST (ledger, fail_change_old) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::change_block block (genesis.hash (), key1.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result1 (ledger.process (transaction, block)); - ASSERT_EQ (rai::process_result::progress, result1.code); - auto result2 (ledger.process (transaction, block)); - ASSERT_EQ (rai::process_result::old, result2.code); -} - -TEST (ledger, fail_change_gap_previous) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::change_block block (1, key1.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result1 (ledger.process (transaction, block)); - ASSERT_EQ (rai::process_result::gap_previous, result1.code); -} - -TEST (ledger, fail_change_bad_signature) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::change_block block (genesis.hash (), key1.pub, rai::keypair ().prv, 0, 0); - auto result1 (ledger.process (transaction, block)); - ASSERT_EQ (rai::process_result::bad_signature, result1.code); -} - -TEST (ledger, fail_change_fork) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::change_block block1 (genesis.hash (), key1.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result1 (ledger.process (transaction, block1)); - ASSERT_EQ (rai::process_result::progress, result1.code); - rai::keypair key2; - rai::change_block block2 (genesis.hash (), key2.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result2 (ledger.process (transaction, block2)); - ASSERT_EQ (rai::process_result::fork, result2.code); -} - -TEST (ledger, fail_send_old) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block (genesis.hash (), key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result1 (ledger.process (transaction, block)); - ASSERT_EQ (rai::process_result::progress, result1.code); - auto result2 (ledger.process (transaction, block)); - ASSERT_EQ (rai::process_result::old, result2.code); -} - -TEST (ledger, fail_send_gap_previous) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block (1, key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result1 (ledger.process (transaction, block)); - ASSERT_EQ (rai::process_result::gap_previous, result1.code); -} - -TEST (ledger, fail_send_bad_signature) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block (genesis.hash (), key1.pub, 1, rai::keypair ().prv, 0, 0); - auto result1 (ledger.process (transaction, block)); - ASSERT_EQ (rai::process_result::bad_signature, result1.code); -} - -TEST (ledger, fail_send_negative_spend) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block1 (genesis.hash (), key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block1).code); - rai::keypair key2; - rai::send_block block2 (block1.hash (), key2.pub, 2, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::negative_spend, ledger.process (transaction, block2).code); -} - -TEST (ledger, fail_send_fork) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block1 (genesis.hash (), key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block1).code); - rai::keypair key2; - rai::send_block block2 (genesis.hash (), key2.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::fork, ledger.process (transaction, block2).code); -} - -TEST (ledger, fail_open_old) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block1 (genesis.hash (), key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block1).code); - rai::open_block block2 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block2).code); - ASSERT_EQ (rai::process_result::old, ledger.process (transaction, block2).code); -} - -TEST (ledger, fail_open_gap_source) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::open_block block2 (1, 1, key1.pub, key1.prv, key1.pub, 0); - auto result2 (ledger.process (transaction, block2)); - ASSERT_EQ (rai::process_result::gap_source, result2.code); -} - -TEST (ledger, fail_open_bad_signature) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block1 (genesis.hash (), key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block1).code); - rai::open_block block2 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); - block2.signature.clear (); - ASSERT_EQ (rai::process_result::bad_signature, ledger.process (transaction, block2).code); -} - -TEST (ledger, fail_open_fork_previous) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block1 (genesis.hash (), key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block1).code); - rai::send_block block2 (block1.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block2).code); - rai::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block3).code); - rai::open_block block4 (block2.hash (), 1, key1.pub, key1.prv, key1.pub, 0); - ASSERT_EQ (rai::process_result::fork, ledger.process (transaction, block4).code); -} - -TEST (ledger, fail_open_account_mismatch) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block1 (genesis.hash (), key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block1).code); - rai::keypair badkey; - rai::open_block block2 (block1.hash (), 1, badkey.pub, badkey.prv, badkey.pub, 0); - ASSERT_NE (rai::process_result::progress, ledger.process (transaction, block2).code); -} - -TEST (ledger, fail_receive_old) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block1 (genesis.hash (), key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block1).code); - rai::send_block block2 (block1.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block2).code); - rai::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block3).code); - rai::receive_block block4 (block3.hash (), block2.hash (), key1.prv, key1.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block4).code); - ASSERT_EQ (rai::process_result::old, ledger.process (transaction, block4).code); -} - -TEST (ledger, fail_receive_gap_source) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block1 (genesis.hash (), key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result1 (ledger.process (transaction, block1)); - ASSERT_EQ (rai::process_result::progress, result1.code); - rai::send_block block2 (block1.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result2 (ledger.process (transaction, block2)); - ASSERT_EQ (rai::process_result::progress, result2.code); - rai::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); - auto result3 (ledger.process (transaction, block3)); - ASSERT_EQ (rai::process_result::progress, result3.code); - rai::receive_block block4 (block3.hash (), 1, key1.prv, key1.pub, 0); - auto result4 (ledger.process (transaction, block4)); - ASSERT_EQ (rai::process_result::gap_source, result4.code); -} - -TEST (ledger, fail_receive_overreceive) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block1 (genesis.hash (), key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result1 (ledger.process (transaction, block1)); - ASSERT_EQ (rai::process_result::progress, result1.code); - rai::open_block block2 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); - auto result3 (ledger.process (transaction, block2)); - ASSERT_EQ (rai::process_result::progress, result3.code); - rai::receive_block block3 (block2.hash (), block1.hash (), key1.prv, key1.pub, 0); - auto result4 (ledger.process (transaction, block3)); - ASSERT_EQ (rai::process_result::unreceivable, result4.code); -} - -TEST (ledger, fail_receive_bad_signature) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block1 (genesis.hash (), key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result1 (ledger.process (transaction, block1)); - ASSERT_EQ (rai::process_result::progress, result1.code); - rai::send_block block2 (block1.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result2 (ledger.process (transaction, block2)); - ASSERT_EQ (rai::process_result::progress, result2.code); - rai::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); - auto result3 (ledger.process (transaction, block3)); - ASSERT_EQ (rai::process_result::progress, result3.code); - rai::receive_block block4 (block3.hash (), block2.hash (), rai::keypair ().prv, 0, 0); - auto result4 (ledger.process (transaction, block4)); - ASSERT_EQ (rai::process_result::bad_signature, result4.code); -} - -TEST (ledger, fail_receive_gap_previous_opened) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block1 (genesis.hash (), key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result1 (ledger.process (transaction, block1)); - ASSERT_EQ (rai::process_result::progress, result1.code); - rai::send_block block2 (block1.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result2 (ledger.process (transaction, block2)); - ASSERT_EQ (rai::process_result::progress, result2.code); - rai::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); - auto result3 (ledger.process (transaction, block3)); - ASSERT_EQ (rai::process_result::progress, result3.code); - rai::receive_block block4 (1, block2.hash (), key1.prv, key1.pub, 0); - auto result4 (ledger.process (transaction, block4)); - ASSERT_EQ (rai::process_result::gap_previous, result4.code); -} - -TEST (ledger, fail_receive_gap_previous_unopened) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block1 (genesis.hash (), key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result1 (ledger.process (transaction, block1)); - ASSERT_EQ (rai::process_result::progress, result1.code); - rai::send_block block2 (block1.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result2 (ledger.process (transaction, block2)); - ASSERT_EQ (rai::process_result::progress, result2.code); - rai::receive_block block3 (1, block2.hash (), key1.prv, key1.pub, 0); - auto result3 (ledger.process (transaction, block3)); - ASSERT_EQ (rai::process_result::gap_previous, result3.code); -} - -TEST (ledger, fail_receive_fork_previous) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block1 (genesis.hash (), key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result1 (ledger.process (transaction, block1)); - ASSERT_EQ (rai::process_result::progress, result1.code); - rai::send_block block2 (block1.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result2 (ledger.process (transaction, block2)); - ASSERT_EQ (rai::process_result::progress, result2.code); - rai::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); - auto result3 (ledger.process (transaction, block3)); - ASSERT_EQ (rai::process_result::progress, result3.code); - rai::keypair key2; - rai::send_block block4 (block3.hash (), key1.pub, 1, key1.prv, key1.pub, 0); - auto result4 (ledger.process (transaction, block4)); - ASSERT_EQ (rai::process_result::progress, result4.code); - rai::receive_block block5 (block3.hash (), block2.hash (), key1.prv, key1.pub, 0); - auto result5 (ledger.process (transaction, block5)); - ASSERT_EQ (rai::process_result::fork, result5.code); -} - -TEST (ledger, fail_receive_received_source) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key1; - rai::send_block block1 (genesis.hash (), key1.pub, 2, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result1 (ledger.process (transaction, block1)); - ASSERT_EQ (rai::process_result::progress, result1.code); - rai::send_block block2 (block1.hash (), key1.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result2 (ledger.process (transaction, block2)); - ASSERT_EQ (rai::process_result::progress, result2.code); - rai::send_block block6 (block2.hash (), key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto result6 (ledger.process (transaction, block6)); - ASSERT_EQ (rai::process_result::progress, result6.code); - rai::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, 0); - auto result3 (ledger.process (transaction, block3)); - ASSERT_EQ (rai::process_result::progress, result3.code); - rai::keypair key2; - rai::send_block block4 (block3.hash (), key1.pub, 1, key1.prv, key1.pub, 0); - auto result4 (ledger.process (transaction, block4)); - ASSERT_EQ (rai::process_result::progress, result4.code); - rai::receive_block block5 (block4.hash (), block2.hash (), key1.prv, key1.pub, 0); - auto result5 (ledger.process (transaction, block5)); - ASSERT_EQ (rai::process_result::progress, result5.code); - rai::receive_block block7 (block3.hash (), block2.hash (), key1.prv, key1.pub, 0); - auto result7 (ledger.process (transaction, block7)); - ASSERT_EQ (rai::process_result::fork, result7.code); -} - -TEST (ledger, latest_empty) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::keypair key; - auto transaction (store.tx_begin ()); - auto latest (ledger.latest (transaction, key.pub)); - ASSERT_TRUE (latest.is_zero ()); -} - -TEST (ledger, latest_root) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_FALSE (init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key; - ASSERT_EQ (key.pub, ledger.latest_root (transaction, key.pub)); - auto hash1 (ledger.latest (transaction, rai::test_genesis_key.pub)); - rai::send_block send (hash1, 0, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send).code); - ASSERT_EQ (send.hash (), ledger.latest_root (transaction, rai::test_genesis_key.pub)); -} - -TEST (ledger, change_representative_move_representation) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::keypair key1; - auto transaction (store.tx_begin (true)); - rai::genesis genesis; - store.initialize (transaction, genesis); - auto hash1 (genesis.hash ()); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::test_genesis_key.pub)); - rai::send_block send (hash1, key1.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send).code); - ASSERT_EQ (0, ledger.weight (transaction, rai::test_genesis_key.pub)); - rai::keypair key2; - rai::change_block change (send.hash (), key2.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, change).code); - rai::keypair key3; - rai::open_block open (send.hash (), key3.pub, key1.pub, key1.prv, key1.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open).code); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, key3.pub)); -} - -TEST (ledger, send_open_receive_rollback) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - auto transaction (store.tx_begin (true)); - rai::genesis genesis; - store.initialize (transaction, genesis); - rai::account_info info1; - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info1)); - rai::keypair key1; - rai::send_block send1 (info1.head, key1.pub, rai::genesis_amount - 50, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto return1 (ledger.process (transaction, send1)); - ASSERT_EQ (rai::process_result::progress, return1.code); - rai::send_block send2 (send1.hash (), key1.pub, rai::genesis_amount - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto return2 (ledger.process (transaction, send2)); - ASSERT_EQ (rai::process_result::progress, return2.code); - rai::keypair key2; - rai::open_block open (send2.hash (), key2.pub, key1.pub, key1.prv, key1.pub, 0); - auto return4 (ledger.process (transaction, open)); - ASSERT_EQ (rai::process_result::progress, return4.code); - rai::receive_block receive (open.hash (), send1.hash (), key1.prv, key1.pub, 0); - auto return5 (ledger.process (transaction, receive)); - ASSERT_EQ (rai::process_result::progress, return5.code); - rai::keypair key3; - ASSERT_EQ (100, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (rai::genesis_amount - 100, ledger.weight (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); - rai::change_block change1 (send2.hash (), key3.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - auto return6 (ledger.process (transaction, change1)); - ASSERT_EQ (rai::process_result::progress, return6.code); - ASSERT_EQ (100, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (0, ledger.weight (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (rai::genesis_amount - 100, ledger.weight (transaction, key3.pub)); - ledger.rollback (transaction, receive.hash ()); - ASSERT_EQ (50, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (0, ledger.weight (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (rai::genesis_amount - 100, ledger.weight (transaction, key3.pub)); - ledger.rollback (transaction, open.hash ()); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (0, ledger.weight (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (rai::genesis_amount - 100, ledger.weight (transaction, key3.pub)); - ledger.rollback (transaction, change1.hash ()); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); - ASSERT_EQ (rai::genesis_amount - 100, ledger.weight (transaction, rai::test_genesis_key.pub)); - ledger.rollback (transaction, send2.hash ()); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); - ASSERT_EQ (rai::genesis_amount - 50, ledger.weight (transaction, rai::test_genesis_key.pub)); - ledger.rollback (transaction, send1.hash ()); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key3.pub)); - ASSERT_EQ (rai::genesis_amount - 0, ledger.weight (transaction, rai::test_genesis_key.pub)); -} - -TEST (ledger, bootstrap_rep_weight) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::account_info info1; - rai::keypair key2; - rai::genesis genesis; - { - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info1)); - rai::send_block send (info1.head, key2.pub, std::numeric_limits::max () - 50, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ledger.process (transaction, send); - } - { - auto transaction (store.tx_begin ()); - ledger.bootstrap_weight_max_blocks = 3; - ledger.bootstrap_weights[key2.pub] = 1000; - ASSERT_EQ (1000, ledger.weight (transaction, key2.pub)); - } - { - auto transaction (store.tx_begin (true)); - ASSERT_FALSE (store.account_get (transaction, rai::test_genesis_key.pub, info1)); - rai::send_block send (info1.head, key2.pub, std::numeric_limits::max () - 100, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ledger.process (transaction, send); - } - { - auto transaction (store.tx_begin ()); - ASSERT_EQ (0, ledger.weight (transaction, key2.pub)); - } -} - -TEST (ledger, block_destination_source) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair dest; - rai::uint128_t balance (rai::genesis_amount); - balance -= rai::Gxrb_ratio; - rai::send_block block1 (genesis.hash (), dest.pub, balance, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - balance -= rai::Gxrb_ratio; - rai::send_block block2 (block1.hash (), rai::genesis_account, balance, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - balance += rai::Gxrb_ratio; - rai::receive_block block3 (block2.hash (), block2.hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - balance -= rai::Gxrb_ratio; - rai::state_block block4 (rai::genesis_account, block3.hash (), rai::genesis_account, balance, dest.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - balance -= rai::Gxrb_ratio; - rai::state_block block5 (rai::genesis_account, block4.hash (), rai::genesis_account, balance, rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - balance += rai::Gxrb_ratio; - rai::state_block block6 (rai::genesis_account, block5.hash (), rai::genesis_account, balance, block5.hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block1).code); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block2).code); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block3).code); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block4).code); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block5).code); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, block6).code); - ASSERT_EQ (balance, ledger.balance (transaction, block6.hash ())); - ASSERT_EQ (dest.pub, ledger.block_destination (transaction, block1)); - ASSERT_TRUE (ledger.block_source (transaction, block1).is_zero ()); - ASSERT_EQ (rai::genesis_account, ledger.block_destination (transaction, block2)); - ASSERT_TRUE (ledger.block_source (transaction, block2).is_zero ()); - ASSERT_TRUE (ledger.block_destination (transaction, block3).is_zero ()); - ASSERT_EQ (block2.hash (), ledger.block_source (transaction, block3)); - ASSERT_EQ (dest.pub, ledger.block_destination (transaction, block4)); - ASSERT_TRUE (ledger.block_source (transaction, block4).is_zero ()); - ASSERT_EQ (rai::genesis_account, ledger.block_destination (transaction, block5)); - ASSERT_TRUE (ledger.block_source (transaction, block5).is_zero ()); - ASSERT_TRUE (ledger.block_destination (transaction, block6).is_zero ()); - ASSERT_EQ (block5.hash (), ledger.block_source (transaction, block6)); -} - -TEST (ledger, state_account) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_EQ (rai::genesis_account, ledger.account (transaction, send1.hash ())); -} - -TEST (ledger, state_send_receive) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); - auto send2 (store.block_get (transaction, send1.hash ())); - ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.weight (transaction, rai::genesis_account)); - ASSERT_TRUE (store.pending_exists (transaction, rai::pending_key (rai::genesis_account, send1.hash ()))); - rai::state_block receive1 (rai::genesis_account, send1.hash (), rai::genesis_account, rai::genesis_amount, send1.hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_TRUE (store.block_exists (transaction, receive1.hash ())); - auto receive2 (store.block_get (transaction, receive1.hash ())); - ASSERT_NE (nullptr, receive2); - ASSERT_EQ (receive1, *receive2); - ASSERT_EQ (rai::genesis_amount, ledger.balance (transaction, receive1.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::genesis_account)); - ASSERT_FALSE (store.pending_exists (transaction, rai::pending_key (rai::genesis_account, send1.hash ()))); -} - -TEST (ledger, state_receive) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::send_block send1 (genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); - auto send2 (store.block_get (transaction, send1.hash ())); - ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.weight (transaction, rai::genesis_account)); - rai::state_block receive1 (rai::genesis_account, send1.hash (), rai::genesis_account, rai::genesis_amount, send1.hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_TRUE (store.block_exists (transaction, receive1.hash ())); - auto receive2 (store.block_get (transaction, receive1.hash ())); - ASSERT_NE (nullptr, receive2); - ASSERT_EQ (receive1, *receive2); - ASSERT_EQ (rai::genesis_amount, ledger.balance (transaction, receive1.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::genesis_account)); -} - -TEST (ledger, state_rep_change) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair rep; - rai::state_block change1 (rai::genesis_account, genesis.hash (), rep.pub, rai::genesis_amount, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, change1).code); - ASSERT_TRUE (store.block_exists (transaction, change1.hash ())); - auto change2 (store.block_get (transaction, change1.hash ())); - ASSERT_NE (nullptr, change2); - ASSERT_EQ (change1, *change2); - ASSERT_EQ (rai::genesis_amount, ledger.balance (transaction, change1.hash ())); - ASSERT_EQ (0, ledger.amount (transaction, change1.hash ())); - ASSERT_EQ (0, ledger.weight (transaction, rai::genesis_account)); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rep.pub)); -} - -TEST (ledger, state_open) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair destination; - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, destination.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); - auto send2 (store.block_get (transaction, send1.hash ())); - ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.weight (transaction, rai::genesis_account)); - ASSERT_TRUE (store.pending_exists (transaction, rai::pending_key (destination.pub, send1.hash ()))); - rai::state_block open1 (destination.pub, 0, rai::genesis_account, rai::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open1).code); - ASSERT_FALSE (store.pending_exists (transaction, rai::pending_key (destination.pub, send1.hash ()))); - ASSERT_TRUE (store.block_exists (transaction, open1.hash ())); - auto open2 (store.block_get (transaction, open1.hash ())); - ASSERT_NE (nullptr, open2); - ASSERT_EQ (open1, *open2); - ASSERT_EQ (rai::Gxrb_ratio, ledger.balance (transaction, open1.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.amount (transaction, open1.hash ())); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::genesis_account)); -} - -// Make sure old block types can't be inserted after a state block. -TEST (ledger, send_after_state_fail) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::send_block send2 (send1.hash (), rai::genesis_account, rai::genesis_amount - (2 * rai::Gxrb_ratio), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::block_position, ledger.process (transaction, send2).code); -} - -// Make sure old block types can't be inserted after a state block. -TEST (ledger, receive_after_state_fail) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::receive_block receive1 (send1.hash (), send1.hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::block_position, ledger.process (transaction, receive1).code); -} - -// Make sure old block types can't be inserted after a state block. -TEST (ledger, change_after_state_fail) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::keypair rep; - rai::change_block change1 (send1.hash (), rep.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::block_position, ledger.process (transaction, change1).code); -} - -TEST (ledger, state_unreceivable_fail) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::send_block send1 (genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); - auto send2 (store.block_get (transaction, send1.hash ())); - ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.weight (transaction, rai::genesis_account)); - rai::state_block receive1 (rai::genesis_account, send1.hash (), rai::genesis_account, rai::genesis_amount, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::gap_source, ledger.process (transaction, receive1).code); -} - -TEST (ledger, state_receive_bad_amount_fail) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::send_block send1 (genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); - auto send2 (store.block_get (transaction, send1.hash ())); - ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.weight (transaction, rai::genesis_account)); - rai::state_block receive1 (rai::genesis_account, send1.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, send1.hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::balance_mismatch, ledger.process (transaction, receive1).code); -} - -TEST (ledger, state_no_link_amount_fail) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::keypair rep; - rai::state_block change1 (rai::genesis_account, send1.hash (), rep.pub, rai::genesis_amount, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::balance_mismatch, ledger.process (transaction, change1).code); -} - -TEST (ledger, state_receive_wrong_account_fail) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); - auto send2 (store.block_get (transaction, send1.hash ())); - ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.weight (transaction, rai::genesis_account)); - rai::keypair key; - rai::state_block receive1 (key.pub, 0, rai::genesis_account, rai::Gxrb_ratio, send1.hash (), key.prv, key.pub, 0); - ASSERT_EQ (rai::process_result::unreceivable, ledger.process (transaction, receive1).code); -} - -TEST (ledger, state_open_state_fork) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair destination; - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, destination.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::state_block open1 (destination.pub, 0, rai::genesis_account, rai::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open1).code); - rai::open_block open2 (send1.hash (), rai::genesis_account, destination.pub, destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::fork, ledger.process (transaction, open2).code); - ASSERT_EQ (open1.root (), open2.root ()); -} - -TEST (ledger, state_state_open_fork) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair destination; - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, destination.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::open_block open1 (send1.hash (), rai::genesis_account, destination.pub, destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open1).code); - rai::state_block open2 (destination.pub, 0, rai::genesis_account, rai::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::fork, ledger.process (transaction, open2).code); - ASSERT_EQ (open1.root (), open2.root ()); -} - -TEST (ledger, state_open_previous_fail) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair destination; - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, destination.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::state_block open1 (destination.pub, destination.pub, rai::genesis_account, rai::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::gap_previous, ledger.process (transaction, open1).code); -} - -TEST (ledger, state_open_source_fail) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair destination; - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, destination.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::state_block open1 (destination.pub, 0, rai::genesis_account, 0, 0, destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::gap_source, ledger.process (transaction, open1).code); -} - -TEST (ledger, state_send_change) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair rep; - rai::state_block send1 (rai::genesis_account, genesis.hash (), rep.pub, rai::genesis_amount - rai::Gxrb_ratio, rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); - auto send2 (store.block_get (transaction, send1.hash ())); - ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (0, ledger.weight (transaction, rai::genesis_account)); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.weight (transaction, rep.pub)); -} - -TEST (ledger, state_receive_change) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); - auto send2 (store.block_get (transaction, send1.hash ())); - ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.balance (transaction, send1.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.weight (transaction, rai::genesis_account)); - rai::keypair rep; - rai::state_block receive1 (rai::genesis_account, send1.hash (), rep.pub, rai::genesis_amount, send1.hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_TRUE (store.block_exists (transaction, receive1.hash ())); - auto receive2 (store.block_get (transaction, receive1.hash ())); - ASSERT_NE (nullptr, receive2); - ASSERT_EQ (receive1, *receive2); - ASSERT_EQ (rai::genesis_amount, ledger.balance (transaction, receive1.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (0, ledger.weight (transaction, rai::genesis_account)); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rep.pub)); -} - -TEST (ledger, state_open_old) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair destination; - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, destination.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::open_block open1 (send1.hash (), rai::genesis_account, destination.pub, destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open1).code); - ASSERT_EQ (rai::Gxrb_ratio, ledger.balance (transaction, open1.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.amount (transaction, open1.hash ())); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::genesis_account)); -} - -TEST (ledger, state_receive_old) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair destination; - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, destination.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::state_block send2 (rai::genesis_account, send1.hash (), rai::genesis_account, rai::genesis_amount - (2 * rai::Gxrb_ratio), destination.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send2).code); - rai::open_block open1 (send1.hash (), rai::genesis_account, destination.pub, destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open1).code); - rai::receive_block receive1 (open1.hash (), send2.hash (), destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_EQ (2 * rai::Gxrb_ratio, ledger.balance (transaction, receive1.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::genesis_account)); -} - -TEST (ledger, state_rollback_send) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store.block_exists (transaction, send1.hash ())); - auto send2 (store.block_get (transaction, send1.hash ())); - ASSERT_NE (nullptr, send2); - ASSERT_EQ (send1, *send2); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.account_balance (transaction, rai::genesis_account)); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.weight (transaction, rai::genesis_account)); - rai::pending_info info; - ASSERT_FALSE (store.pending_get (transaction, rai::pending_key (rai::genesis_account, send1.hash ()), info)); - ASSERT_EQ (rai::genesis_account, info.source); - ASSERT_EQ (rai::Gxrb_ratio, info.amount.number ()); - ledger.rollback (transaction, send1.hash ()); - ASSERT_FALSE (store.block_exists (transaction, send1.hash ())); - ASSERT_EQ (rai::genesis_amount, ledger.account_balance (transaction, rai::genesis_account)); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::genesis_account)); - ASSERT_FALSE (store.pending_exists (transaction, rai::pending_key (rai::genesis_account, send1.hash ()))); - ASSERT_TRUE (store.block_successor (transaction, genesis.hash ()).is_zero ()); -} - -TEST (ledger, state_rollback_receive) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::state_block receive1 (rai::genesis_account, send1.hash (), rai::genesis_account, rai::genesis_amount, send1.hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_FALSE (store.pending_exists (transaction, rai::pending_key (rai::genesis_account, receive1.hash ()))); - ledger.rollback (transaction, receive1.hash ()); - rai::pending_info info; - ASSERT_FALSE (store.pending_get (transaction, rai::pending_key (rai::genesis_account, send1.hash ()), info)); - ASSERT_EQ (rai::genesis_account, info.source); - ASSERT_EQ (rai::Gxrb_ratio, info.amount.number ()); - ASSERT_FALSE (store.block_exists (transaction, receive1.hash ())); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.account_balance (transaction, rai::genesis_account)); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.weight (transaction, rai::genesis_account)); -} - -TEST (ledger, state_rollback_received_send) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair key; - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, key.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::state_block receive1 (key.pub, 0, key.pub, rai::Gxrb_ratio, send1.hash (), key.prv, key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_FALSE (store.pending_exists (transaction, rai::pending_key (rai::genesis_account, receive1.hash ()))); - ledger.rollback (transaction, send1.hash ()); - ASSERT_FALSE (store.pending_exists (transaction, rai::pending_key (rai::genesis_account, send1.hash ()))); - ASSERT_FALSE (store.block_exists (transaction, send1.hash ())); - ASSERT_FALSE (store.block_exists (transaction, receive1.hash ())); - ASSERT_EQ (rai::genesis_amount, ledger.account_balance (transaction, rai::genesis_account)); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::genesis_account)); - ASSERT_EQ (0, ledger.account_balance (transaction, key.pub)); - ASSERT_EQ (0, ledger.weight (transaction, key.pub)); -} - -TEST (ledger, state_rep_change_rollback) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair rep; - rai::state_block change1 (rai::genesis_account, genesis.hash (), rep.pub, rai::genesis_amount, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, change1).code); - ledger.rollback (transaction, change1.hash ()); - ASSERT_FALSE (store.block_exists (transaction, change1.hash ())); - ASSERT_EQ (rai::genesis_amount, ledger.account_balance (transaction, rai::genesis_account)); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::genesis_account)); - ASSERT_EQ (0, ledger.weight (transaction, rep.pub)); -} - -TEST (ledger, state_open_rollback) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair destination; - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, destination.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::state_block open1 (destination.pub, 0, rai::genesis_account, rai::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open1).code); - ledger.rollback (transaction, open1.hash ()); - ASSERT_FALSE (store.block_exists (transaction, open1.hash ())); - ASSERT_EQ (0, ledger.account_balance (transaction, destination.pub)); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.weight (transaction, rai::genesis_account)); - rai::pending_info info; - ASSERT_FALSE (store.pending_get (transaction, rai::pending_key (destination.pub, send1.hash ()), info)); - ASSERT_EQ (rai::genesis_account, info.source); - ASSERT_EQ (rai::Gxrb_ratio, info.amount.number ()); -} - -TEST (ledger, state_send_change_rollback) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair rep; - rai::state_block send1 (rai::genesis_account, genesis.hash (), rep.pub, rai::genesis_amount - rai::Gxrb_ratio, rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - ledger.rollback (transaction, send1.hash ()); - ASSERT_FALSE (store.block_exists (transaction, send1.hash ())); - ASSERT_EQ (rai::genesis_amount, ledger.account_balance (transaction, rai::genesis_account)); - ASSERT_EQ (rai::genesis_amount, ledger.weight (transaction, rai::genesis_account)); - ASSERT_EQ (0, ledger.weight (transaction, rep.pub)); -} - -TEST (ledger, state_receive_change_rollback) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::ledger ledger (store, stats); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::keypair rep; - rai::state_block receive1 (rai::genesis_account, send1.hash (), rep.pub, rai::genesis_amount, send1.hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, receive1).code); - ledger.rollback (transaction, receive1.hash ()); - ASSERT_FALSE (store.block_exists (transaction, receive1.hash ())); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.account_balance (transaction, rai::genesis_account)); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.weight (transaction, rai::genesis_account)); - ASSERT_EQ (0, ledger.weight (transaction, rep.pub)); -} - -TEST (ledger, epoch_blocks_general) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::keypair epoch_key; - rai::ledger ledger (store, stats, 123, epoch_key.pub); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair destination; - rai::state_block epoch1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount, 123, epoch_key.prv, epoch_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, epoch1).code); - rai::state_block epoch2 (rai::genesis_account, epoch1.hash (), rai::genesis_account, rai::genesis_amount, 123, epoch_key.prv, epoch_key.pub, 0); - ASSERT_EQ (rai::process_result::block_position, ledger.process (transaction, epoch2).code); - rai::account_info genesis_info; - ASSERT_FALSE (ledger.store.account_get (transaction, rai::genesis_account, genesis_info)); - ASSERT_EQ (genesis_info.epoch, rai::epoch::epoch_1); - ledger.rollback (transaction, epoch1.hash ()); - ASSERT_FALSE (ledger.store.account_get (transaction, rai::genesis_account, genesis_info)); - ASSERT_EQ (genesis_info.epoch, rai::epoch::epoch_0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, epoch1).code); - ASSERT_FALSE (ledger.store.account_get (transaction, rai::genesis_account, genesis_info)); - ASSERT_EQ (genesis_info.epoch, rai::epoch::epoch_1); - rai::change_block change1 (epoch1.hash (), rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::block_position, ledger.process (transaction, change1).code); - rai::state_block send1 (rai::genesis_account, epoch1.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, destination.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::open_block open1 (send1.hash (), rai::genesis_account, destination.pub, destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::unreceivable, ledger.process (transaction, open1).code); - rai::state_block epoch3 (destination.pub, 0, rai::genesis_account, 0, 123, epoch_key.prv, epoch_key.pub, 0); - ASSERT_EQ (rai::process_result::representative_mismatch, ledger.process (transaction, epoch3).code); - rai::state_block epoch4 (destination.pub, 0, 0, 0, 123, epoch_key.prv, epoch_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, epoch4).code); - rai::receive_block receive1 (epoch4.hash (), send1.hash (), destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::block_position, ledger.process (transaction, receive1).code); - rai::state_block receive2 (destination.pub, epoch4.hash (), destination.pub, rai::Gxrb_ratio, send1.hash (), destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, receive2).code); - ASSERT_EQ (0, ledger.balance (transaction, epoch4.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.balance (transaction, receive2.hash ())); - ASSERT_EQ (rai::Gxrb_ratio, ledger.amount (transaction, receive2.hash ())); - ASSERT_EQ (rai::genesis_amount - rai::Gxrb_ratio, ledger.weight (transaction, rai::genesis_account)); - ASSERT_EQ (rai::Gxrb_ratio, ledger.weight (transaction, destination.pub)); -} - -TEST (ledger, epoch_blocks_receive_upgrade) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::keypair epoch_key; - rai::ledger ledger (store, stats, 123, epoch_key.pub); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair destination; - rai::state_block send1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, destination.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::state_block epoch1 (rai::genesis_account, send1.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio, 123, epoch_key.prv, epoch_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, epoch1).code); - rai::state_block send2 (rai::genesis_account, epoch1.hash (), rai::genesis_account, rai::genesis_amount - rai::Gxrb_ratio * 2, destination.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send2).code); - rai::open_block open1 (send1.hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open1).code); - rai::receive_block receive1 (open1.hash (), send2.hash (), destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::unreceivable, ledger.process (transaction, receive1).code); - rai::state_block receive2 (destination.pub, open1.hash (), destination.pub, rai::Gxrb_ratio * 2, send2.hash (), destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, receive2).code); - rai::account_info destination_info; - ASSERT_FALSE (ledger.store.account_get (transaction, destination.pub, destination_info)); - ASSERT_EQ (destination_info.epoch, rai::epoch::epoch_1); - ledger.rollback (transaction, receive2.hash ()); - ASSERT_FALSE (ledger.store.account_get (transaction, destination.pub, destination_info)); - ASSERT_EQ (destination_info.epoch, rai::epoch::epoch_0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, receive2).code); - ASSERT_FALSE (ledger.store.account_get (transaction, destination.pub, destination_info)); - ASSERT_EQ (destination_info.epoch, rai::epoch::epoch_1); - rai::keypair destination2; - rai::state_block send3 (destination.pub, receive2.hash (), destination.pub, rai::Gxrb_ratio, destination2.pub, destination.prv, destination.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send3).code); - rai::open_block open2 (send3.hash (), destination2.pub, destination2.pub, destination2.prv, destination2.pub, 0); - ASSERT_EQ (rai::process_result::unreceivable, ledger.process (transaction, open2).code); -} - -TEST (ledger, epoch_blocks_fork) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::keypair epoch_key; - rai::ledger ledger (store, stats, 123, epoch_key.pub); - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair destination; - rai::send_block send1 (genesis.hash (), rai::account (0), rai::genesis_amount, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send1).code); - rai::state_block epoch1 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount, 123, epoch_key.prv, epoch_key.pub, 0); - ASSERT_EQ (rai::process_result::fork, ledger.process (transaction, epoch1).code); -} - -TEST (ledger, could_fit) -{ - bool init (false); - rai::mdb_store store (init, rai::unique_path ()); - ASSERT_TRUE (!init); - rai::stat stats; - rai::keypair epoch_key; - rai::ledger ledger (store, stats, 123, epoch_key.pub); - rai::keypair epoch_signer; - ledger.epoch_link = 123; - ledger.epoch_signer = epoch_signer.pub; - rai::genesis genesis; - auto transaction (store.tx_begin (true)); - store.initialize (transaction, genesis); - rai::keypair destination; - // Test legacy and state change blocks could_fit - rai::change_block change1 (genesis.hash (), rai::genesis_account, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::state_block change2 (rai::genesis_account, genesis.hash (), rai::genesis_account, rai::genesis_amount, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_TRUE (ledger.could_fit (transaction, change1)); - ASSERT_TRUE (ledger.could_fit (transaction, change2)); - // Test legacy and state send - rai::keypair key1; - rai::send_block send1 (change1.hash (), key1.pub, rai::genesis_amount - 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - rai::state_block send2 (rai::genesis_account, change1.hash (), rai::genesis_account, rai::genesis_amount - 1, key1.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - ASSERT_FALSE (ledger.could_fit (transaction, send1)); - ASSERT_FALSE (ledger.could_fit (transaction, send2)); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, change1).code); - ASSERT_TRUE (ledger.could_fit (transaction, change1)); - ASSERT_TRUE (ledger.could_fit (transaction, change2)); - ASSERT_TRUE (ledger.could_fit (transaction, send1)); - ASSERT_TRUE (ledger.could_fit (transaction, send2)); - // Test legacy and state open - rai::open_block open1 (send2.hash (), rai::genesis_account, key1.pub, key1.prv, key1.pub, 0); - rai::state_block open2 (key1.pub, 0, rai::genesis_account, 1, send2.hash (), key1.prv, key1.pub, 0); - ASSERT_FALSE (ledger.could_fit (transaction, open1)); - ASSERT_FALSE (ledger.could_fit (transaction, open2)); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send2).code); - ASSERT_TRUE (ledger.could_fit (transaction, send1)); - ASSERT_TRUE (ledger.could_fit (transaction, send2)); - ASSERT_TRUE (ledger.could_fit (transaction, open1)); - ASSERT_TRUE (ledger.could_fit (transaction, open2)); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, open1).code); - ASSERT_TRUE (ledger.could_fit (transaction, open1)); - ASSERT_TRUE (ledger.could_fit (transaction, open2)); - // Create another send to receive - rai::state_block send3 (rai::genesis_account, send2.hash (), rai::genesis_account, rai::genesis_amount - 2, key1.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - // Test legacy and state receive - rai::receive_block receive1 (open1.hash (), send3.hash (), key1.prv, key1.pub, 0); - rai::state_block receive2 (key1.pub, open1.hash (), rai::genesis_account, 2, send3.hash (), key1.prv, key1.pub, 0); - ASSERT_FALSE (ledger.could_fit (transaction, receive1)); - ASSERT_FALSE (ledger.could_fit (transaction, receive2)); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, send3).code); - ASSERT_TRUE (ledger.could_fit (transaction, receive1)); - ASSERT_TRUE (ledger.could_fit (transaction, receive2)); - // Test epoch (state) - rai::state_block epoch1 (key1.pub, receive1.hash (), rai::genesis_account, 2, ledger.epoch_link, epoch_signer.prv, epoch_signer.pub, 0); - ASSERT_FALSE (ledger.could_fit (transaction, epoch1)); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_TRUE (ledger.could_fit (transaction, receive1)); - ASSERT_TRUE (ledger.could_fit (transaction, receive2)); - ASSERT_TRUE (ledger.could_fit (transaction, epoch1)); - ASSERT_EQ (rai::process_result::progress, ledger.process (transaction, epoch1).code); - ASSERT_TRUE (ledger.could_fit (transaction, epoch1)); -} diff --git a/rai/core_test/message.cpp b/rai/core_test/message.cpp deleted file mode 100644 index 44f589dd..00000000 --- a/rai/core_test/message.cpp +++ /dev/null @@ -1,85 +0,0 @@ -#include - -#include - -TEST (message, keepalive_serialization) -{ - rai::keepalive request1; - std::vector bytes; - { - rai::vectorstream stream (bytes); - request1.serialize (stream); - } - auto error (false); - rai::bufferstream stream (bytes.data (), bytes.size ()); - rai::message_header header (error, stream); - ASSERT_FALSE (error); - rai::keepalive request2 (error, stream, header); - ASSERT_FALSE (error); - ASSERT_EQ (request1, request2); -} - -TEST (message, keepalive_deserialize) -{ - rai::keepalive message1; - message1.peers[0] = rai::endpoint (boost::asio::ip::address_v6::loopback (), 10000); - std::vector bytes; - { - rai::vectorstream stream (bytes); - message1.serialize (stream); - } - rai::bufferstream stream (bytes.data (), bytes.size ()); - auto error (false); - rai::message_header header (error, stream); - ASSERT_FALSE (error); - ASSERT_EQ (rai::message_type::keepalive, header.type); - rai::keepalive message2 (error, stream, header); - ASSERT_FALSE (error); - ASSERT_EQ (message1.peers, message2.peers); -} - -TEST (message, publish_serialization) -{ - rai::publish publish (std::make_shared (0, 1, 2, rai::keypair ().prv, 4, 5)); - ASSERT_EQ (rai::block_type::send, publish.header.block_type ()); - std::vector bytes; - { - rai::vectorstream stream (bytes); - publish.header.serialize (stream); - } - ASSERT_EQ (8, bytes.size ()); - ASSERT_EQ (0x52, bytes[0]); - ASSERT_EQ (0x41, bytes[1]); - ASSERT_EQ (rai::protocol_version, bytes[2]); - ASSERT_EQ (rai::protocol_version, bytes[3]); - ASSERT_EQ (rai::protocol_version_min, bytes[4]); - ASSERT_EQ (static_cast (rai::message_type::publish), bytes[5]); - ASSERT_EQ (0x00, bytes[6]); // extensions - ASSERT_EQ (static_cast (rai::block_type::send), bytes[7]); - rai::bufferstream stream (bytes.data (), bytes.size ()); - auto error (false); - rai::message_header header (error, stream); - ASSERT_FALSE (error); - ASSERT_EQ (rai::protocol_version_min, header.version_min); - ASSERT_EQ (rai::protocol_version, header.version_using); - ASSERT_EQ (rai::protocol_version, header.version_max); - ASSERT_EQ (rai::message_type::publish, header.type); -} - -TEST (message, confirm_ack_serialization) -{ - rai::keypair key1; - auto vote (std::make_shared (key1.pub, key1.prv, 0, std::make_shared (0, 1, 2, key1.prv, 4, 5))); - rai::confirm_ack con1 (vote); - std::vector bytes; - { - rai::vectorstream stream1 (bytes); - con1.serialize (stream1); - } - rai::bufferstream stream2 (bytes.data (), bytes.size ()); - bool error (false); - rai::message_header header (error, stream2); - rai::confirm_ack con2 (error, stream2, header); - ASSERT_FALSE (error); - ASSERT_EQ (con1, con2); -} diff --git a/rai/core_test/message_parser.cpp b/rai/core_test/message_parser.cpp deleted file mode 100644 index 67575bb2..00000000 --- a/rai/core_test/message_parser.cpp +++ /dev/null @@ -1,200 +0,0 @@ -#include -#include - -namespace -{ -class test_visitor : public rai::message_visitor -{ -public: - test_visitor () : - keepalive_count (0), - publish_count (0), - confirm_req_count (0), - confirm_ack_count (0), - bulk_pull_count (0), - bulk_pull_account_count (0), - bulk_pull_blocks_count (0), - bulk_push_count (0), - frontier_req_count (0) - { - } - void keepalive (rai::keepalive const &) override - { - ++keepalive_count; - } - void publish (rai::publish const &) override - { - ++publish_count; - } - void confirm_req (rai::confirm_req const &) override - { - ++confirm_req_count; - } - void confirm_ack (rai::confirm_ack const &) override - { - ++confirm_ack_count; - } - void bulk_pull (rai::bulk_pull const &) override - { - ++bulk_pull_count; - } - void bulk_pull_account (rai::bulk_pull_account const &) override - { - ++bulk_pull_account_count; - } - void bulk_pull_blocks (rai::bulk_pull_blocks const &) override - { - ++bulk_pull_blocks_count; - } - void bulk_push (rai::bulk_push const &) override - { - ++bulk_push_count; - } - void frontier_req (rai::frontier_req const &) override - { - ++frontier_req_count; - } - void node_id_handshake (rai::node_id_handshake const &) override - { - ++node_id_handshake_count; - } - uint64_t keepalive_count; - uint64_t publish_count; - uint64_t confirm_req_count; - uint64_t confirm_ack_count; - uint64_t bulk_pull_count; - uint64_t bulk_pull_account_count; - uint64_t bulk_pull_blocks_count; - uint64_t bulk_push_count; - uint64_t frontier_req_count; - uint64_t node_id_handshake_count; -}; -} - -TEST (message_parser, exact_confirm_ack_size) -{ - rai::system system (24000, 1); - test_visitor visitor; - rai::block_uniquer block_uniquer; - rai::vote_uniquer vote_uniquer (block_uniquer); - rai::message_parser parser (block_uniquer, vote_uniquer, visitor, system.work); - auto block (std::make_shared (1, 1, 2, rai::keypair ().prv, 4, system.work.generate (1))); - auto vote (std::make_shared (0, rai::keypair ().prv, 0, std::move (block))); - rai::confirm_ack message (vote); - std::vector bytes; - { - rai::vectorstream stream (bytes); - message.serialize (stream); - } - ASSERT_EQ (0, visitor.confirm_ack_count); - ASSERT_EQ (parser.status, rai::message_parser::parse_status::success); - auto error (false); - rai::bufferstream stream1 (bytes.data (), bytes.size ()); - rai::message_header header1 (error, stream1); - ASSERT_FALSE (error); - parser.deserialize_confirm_ack (stream1, header1); - ASSERT_EQ (1, visitor.confirm_ack_count); - ASSERT_EQ (parser.status, rai::message_parser::parse_status::success); - bytes.push_back (0); - rai::bufferstream stream2 (bytes.data (), bytes.size ()); - rai::message_header header2 (error, stream2); - ASSERT_FALSE (error); - parser.deserialize_confirm_ack (stream2, header2); - ASSERT_EQ (1, visitor.confirm_ack_count); - ASSERT_NE (parser.status, rai::message_parser::parse_status::success); -} - -TEST (message_parser, exact_confirm_req_size) -{ - rai::system system (24000, 1); - test_visitor visitor; - rai::block_uniquer block_uniquer; - rai::vote_uniquer vote_uniquer (block_uniquer); - rai::message_parser parser (block_uniquer, vote_uniquer, visitor, system.work); - auto block (std::make_shared (1, 1, 2, rai::keypair ().prv, 4, system.work.generate (1))); - rai::confirm_req message (std::move (block)); - std::vector bytes; - { - rai::vectorstream stream (bytes); - message.serialize (stream); - } - ASSERT_EQ (0, visitor.confirm_req_count); - ASSERT_EQ (parser.status, rai::message_parser::parse_status::success); - auto error (false); - rai::bufferstream stream1 (bytes.data (), bytes.size ()); - rai::message_header header1 (error, stream1); - ASSERT_FALSE (error); - parser.deserialize_confirm_req (stream1, header1); - ASSERT_EQ (1, visitor.confirm_req_count); - ASSERT_EQ (parser.status, rai::message_parser::parse_status::success); - bytes.push_back (0); - rai::bufferstream stream2 (bytes.data (), bytes.size ()); - rai::message_header header2 (error, stream2); - ASSERT_FALSE (error); - parser.deserialize_confirm_req (stream2, header2); - ASSERT_EQ (1, visitor.confirm_req_count); - ASSERT_NE (parser.status, rai::message_parser::parse_status::success); -} - -TEST (message_parser, exact_publish_size) -{ - rai::system system (24000, 1); - test_visitor visitor; - rai::block_uniquer block_uniquer; - rai::vote_uniquer vote_uniquer (block_uniquer); - rai::message_parser parser (block_uniquer, vote_uniquer, visitor, system.work); - auto block (std::make_shared (1, 1, 2, rai::keypair ().prv, 4, system.work.generate (1))); - rai::publish message (std::move (block)); - std::vector bytes; - { - rai::vectorstream stream (bytes); - message.serialize (stream); - } - ASSERT_EQ (0, visitor.publish_count); - ASSERT_EQ (parser.status, rai::message_parser::parse_status::success); - auto error (false); - rai::bufferstream stream1 (bytes.data (), bytes.size ()); - rai::message_header header1 (error, stream1); - ASSERT_FALSE (error); - parser.deserialize_publish (stream1, header1); - ASSERT_EQ (1, visitor.publish_count); - ASSERT_EQ (parser.status, rai::message_parser::parse_status::success); - bytes.push_back (0); - rai::bufferstream stream2 (bytes.data (), bytes.size ()); - rai::message_header header2 (error, stream2); - ASSERT_FALSE (error); - parser.deserialize_publish (stream2, header2); - ASSERT_EQ (1, visitor.publish_count); - ASSERT_NE (parser.status, rai::message_parser::parse_status::success); -} - -TEST (message_parser, exact_keepalive_size) -{ - rai::system system (24000, 1); - test_visitor visitor; - rai::block_uniquer block_uniquer; - rai::vote_uniquer vote_uniquer (block_uniquer); - rai::message_parser parser (block_uniquer, vote_uniquer, visitor, system.work); - rai::keepalive message; - std::vector bytes; - { - rai::vectorstream stream (bytes); - message.serialize (stream); - } - ASSERT_EQ (0, visitor.keepalive_count); - ASSERT_EQ (parser.status, rai::message_parser::parse_status::success); - auto error (false); - rai::bufferstream stream1 (bytes.data (), bytes.size ()); - rai::message_header header1 (error, stream1); - ASSERT_FALSE (error); - parser.deserialize_keepalive (stream1, header1); - ASSERT_EQ (1, visitor.keepalive_count); - ASSERT_EQ (parser.status, rai::message_parser::parse_status::success); - bytes.push_back (0); - rai::bufferstream stream2 (bytes.data (), bytes.size ()); - rai::message_header header2 (error, stream2); - ASSERT_FALSE (error); - parser.deserialize_keepalive (stream2, header2); - ASSERT_EQ (1, visitor.keepalive_count); - ASSERT_NE (parser.status, rai::message_parser::parse_status::success); -} diff --git a/rai/core_test/network.cpp b/rai/core_test/network.cpp deleted file mode 100644 index 58615e3d..00000000 --- a/rai/core_test/network.cpp +++ /dev/null @@ -1,1275 +0,0 @@ -#include -#include -#include -#include - -using namespace std::chrono_literals; - -TEST (network, tcp_connection) -{ - boost::asio::io_context io_ctx; - boost::asio::ip::tcp::acceptor acceptor (io_ctx); - boost::asio::ip::tcp::endpoint endpoint (boost::asio::ip::address_v4::any (), 24000); - acceptor.open (endpoint.protocol ()); - acceptor.set_option (boost::asio::ip::tcp::acceptor::reuse_address (true)); - acceptor.bind (endpoint); - acceptor.listen (); - boost::asio::ip::tcp::socket incoming (io_ctx); - auto done1 (false); - std::string message1; - acceptor.async_accept (incoming, - [&done1, &message1](boost::system::error_code const & ec_a) { - if (ec_a) - { - message1 = ec_a.message (); - std::cerr << message1; - } - done1 = true; }); - boost::asio::ip::tcp::socket connector (io_ctx); - auto done2 (false); - std::string message2; - connector.async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), 24000), - [&done2, &message2](boost::system::error_code const & ec_a) { - if (ec_a) - { - message2 = ec_a.message (); - std::cerr << message2; - } - done2 = true; - }); - while (!done1 || !done2) - { - io_ctx.poll (); - } - ASSERT_EQ (0, message1.size ()); - ASSERT_EQ (0, message2.size ()); -} - -TEST (network, construction) -{ - rai::system system (24000, 1); - ASSERT_EQ (1, system.nodes.size ()); - ASSERT_EQ (24000, system.nodes[0]->network.socket.local_endpoint ().port ()); -} - -TEST (network, self_discard) -{ - rai::system system (24000, 1); - rai::udp_data data; - data.endpoint = system.nodes[0]->network.endpoint (); - ASSERT_EQ (0, system.nodes[0]->stats.count (rai::stat::type::error, rai::stat::detail::bad_sender)); - system.nodes[0]->network.receive_action (&data); - ASSERT_EQ (1, system.nodes[0]->stats.count (rai::stat::type::error, rai::stat::detail::bad_sender)); -} - -TEST (network, send_node_id_handshake) -{ - rai::system system (24000, 1); - auto list1 (system.nodes[0]->peers.list ()); - ASSERT_EQ (0, list1.size ()); - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); - node1->start (); - system.nodes.push_back (node1); - auto initial (system.nodes[0]->stats.count (rai::stat::type::message, rai::stat::detail::node_id_handshake, rai::stat::dir::in)); - auto initial_node1 (node1->stats.count (rai::stat::type::message, rai::stat::detail::node_id_handshake, rai::stat::dir::in)); - system.nodes[0]->network.send_keepalive (node1->network.endpoint ()); - ASSERT_EQ (0, system.nodes[0]->peers.list ().size ()); - ASSERT_EQ (0, node1->peers.list ().size ()); - system.deadline_set (10s); - while (node1->stats.count (rai::stat::type::message, rai::stat::detail::node_id_handshake, rai::stat::dir::in) == initial_node1) - { - ASSERT_NO_ERROR (system.poll ()); - } - ASSERT_EQ (0, system.nodes[0]->peers.list ().size ()); - ASSERT_EQ (1, node1->peers.list ().size ()); - system.deadline_set (10s); - while (system.nodes[0]->stats.count (rai::stat::type::message, rai::stat::detail::node_id_handshake, rai::stat::dir::in) < initial + 2) - { - ASSERT_NO_ERROR (system.poll ()); - } - auto peers1 (system.nodes[0]->peers.list ()); - auto peers2 (node1->peers.list ()); - ASSERT_EQ (1, peers1.size ()); - ASSERT_EQ (1, peers2.size ()); - ASSERT_EQ (node1->network.endpoint (), peers1[0]); - ASSERT_EQ (system.nodes[0]->network.endpoint (), peers2[0]); - node1->stop (); -} - -TEST (network, keepalive_ipv4) -{ - rai::system system (24000, 1); - auto list1 (system.nodes[0]->peers.list ()); - ASSERT_EQ (0, list1.size ()); - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); - node1->start (); - system.nodes.push_back (node1); - node1->send_keepalive (rai::endpoint (boost::asio::ip::address_v4::loopback (), 24000)); - auto initial (system.nodes[0]->stats.count (rai::stat::type::message, rai::stat::detail::keepalive, rai::stat::dir::in)); - system.deadline_set (10s); - while (system.nodes[0]->stats.count (rai::stat::type::message, rai::stat::detail::keepalive, rai::stat::dir::in) == initial) - { - ASSERT_NO_ERROR (system.poll ()); - } - node1->stop (); -} - -TEST (network, multi_keepalive) -{ - rai::system system (24000, 1); - auto list1 (system.nodes[0]->peers.list ()); - ASSERT_EQ (0, list1.size ()); - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); - node1->start (); - system.nodes.push_back (node1); - ASSERT_EQ (0, node1->peers.size ()); - node1->network.send_keepalive (system.nodes[0]->network.endpoint ()); - ASSERT_EQ (0, node1->peers.size ()); - ASSERT_EQ (0, system.nodes[0]->peers.size ()); - system.deadline_set (10s); - while (system.nodes[0]->peers.size () != 1) - { - ASSERT_NO_ERROR (system.poll ()); - } - rai::node_init init2; - auto node2 (std::make_shared (init2, system.io_ctx, 24002, rai::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init2.error ()); - node2->start (); - system.nodes.push_back (node2); - node2->network.send_keepalive (system.nodes[0]->network.endpoint ()); - system.deadline_set (10s); - while (node1->peers.size () != 2 || system.nodes[0]->peers.size () != 2 || node2->peers.size () != 2) - { - ASSERT_NO_ERROR (system.poll ()); - } - node1->stop (); - node2->stop (); -} - -TEST (network, send_discarded_publish) -{ - rai::system system (24000, 2); - auto block (std::make_shared (1, 1, 2, rai::keypair ().prv, 4, system.work.generate (1))); - rai::genesis genesis; - { - auto transaction (system.nodes[0]->store.tx_begin ()); - system.nodes[0]->network.republish_block (block); - ASSERT_EQ (genesis.hash (), system.nodes[0]->ledger.latest (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (genesis.hash (), system.nodes[1]->latest (rai::test_genesis_key.pub)); - } - system.deadline_set (10s); - while (system.nodes[1]->stats.count (rai::stat::type::message, rai::stat::detail::publish, rai::stat::dir::in) == 0) - { - ASSERT_NO_ERROR (system.poll ()); - } - auto transaction (system.nodes[0]->store.tx_begin ()); - ASSERT_EQ (genesis.hash (), system.nodes[0]->ledger.latest (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (genesis.hash (), system.nodes[1]->latest (rai::test_genesis_key.pub)); -} - -TEST (network, send_invalid_publish) -{ - rai::system system (24000, 2); - rai::genesis genesis; - auto block (std::make_shared (1, 1, 20, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (1))); - { - auto transaction (system.nodes[0]->store.tx_begin ()); - system.nodes[0]->network.republish_block (block); - ASSERT_EQ (genesis.hash (), system.nodes[0]->ledger.latest (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (genesis.hash (), system.nodes[1]->latest (rai::test_genesis_key.pub)); - } - system.deadline_set (10s); - while (system.nodes[1]->stats.count (rai::stat::type::message, rai::stat::detail::publish, rai::stat::dir::in) == 0) - { - ASSERT_NO_ERROR (system.poll ()); - } - auto transaction (system.nodes[0]->store.tx_begin ()); - ASSERT_EQ (genesis.hash (), system.nodes[0]->ledger.latest (transaction, rai::test_genesis_key.pub)); - ASSERT_EQ (genesis.hash (), system.nodes[1]->latest (rai::test_genesis_key.pub)); -} - -TEST (network, send_valid_confirm_ack) -{ - rai::system system (24000, 2); - rai::keypair key2; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - system.wallet (1)->insert_adhoc (key2.prv); - rai::block_hash latest1 (system.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::send_block block2 (latest1, key2.pub, 50, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (latest1)); - rai::block_hash latest2 (system.nodes[1]->latest (rai::test_genesis_key.pub)); - system.nodes[0]->process_active (std::make_shared (block2)); - system.deadline_set (10s); - // Keep polling until latest block changes - while (system.nodes[1]->latest (rai::test_genesis_key.pub) == latest2) - { - ASSERT_NO_ERROR (system.poll ()); - } - // Make sure the balance has decreased after processing the block. - ASSERT_EQ (50, system.nodes[1]->balance (rai::test_genesis_key.pub)); -} - -TEST (network, send_valid_publish) -{ - rai::system system (24000, 2); - system.nodes[0]->bootstrap_initiator.stop (); - system.nodes[1]->bootstrap_initiator.stop (); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key2; - system.wallet (1)->insert_adhoc (key2.prv); - rai::block_hash latest1 (system.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::send_block block2 (latest1, key2.pub, 50, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (latest1)); - auto hash2 (block2.hash ()); - rai::block_hash latest2 (system.nodes[1]->latest (rai::test_genesis_key.pub)); - system.nodes[1]->process_active (std::make_shared (block2)); - system.deadline_set (10s); - while (system.nodes[0]->stats.count (rai::stat::type::message, rai::stat::detail::publish, rai::stat::dir::in) == 0) - { - ASSERT_NO_ERROR (system.poll ()); - } - ASSERT_NE (hash2, latest2); - system.deadline_set (10s); - while (system.nodes[1]->latest (rai::test_genesis_key.pub) == latest2) - { - ASSERT_NO_ERROR (system.poll ()); - } - ASSERT_EQ (50, system.nodes[1]->balance (rai::test_genesis_key.pub)); -} - -TEST (network, send_insufficient_work) -{ - rai::system system (24000, 2); - auto block (std::make_shared (0, 1, 20, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - rai::publish publish (std::move (block)); - std::shared_ptr> bytes (new std::vector); - { - rai::vectorstream stream (*bytes); - publish.serialize (stream); - } - auto node1 (system.nodes[1]->shared ()); - system.nodes[0]->network.send_buffer (bytes->data (), bytes->size (), system.nodes[1]->network.endpoint (), [bytes, node1](boost::system::error_code const & ec, size_t size) {}); - ASSERT_EQ (0, system.nodes[0]->stats.count (rai::stat::type::error, rai::stat::detail::insufficient_work)); - system.deadline_set (10s); - while (system.nodes[1]->stats.count (rai::stat::type::error, rai::stat::detail::insufficient_work) == 0) - { - ASSERT_NO_ERROR (system.poll ()); - } - ASSERT_EQ (1, system.nodes[1]->stats.count (rai::stat::type::error, rai::stat::detail::insufficient_work)); -} - -TEST (receivable_processor, confirm_insufficient_pos) -{ - rai::system system (24000, 1); - auto & node1 (*system.nodes[0]); - rai::genesis genesis; - auto block1 (std::make_shared (genesis.hash (), 0, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*block1); - ASSERT_EQ (rai::process_result::progress, node1.process (*block1).code); - auto node_l (system.nodes[0]); - node1.active.start (block1); - rai::keypair key1; - auto vote (std::make_shared (key1.pub, key1.prv, 0, block1)); - rai::confirm_ack con1 (vote); - node1.process_message (con1, node1.network.endpoint ()); -} - -TEST (receivable_processor, confirm_sufficient_pos) -{ - rai::system system (24000, 1); - auto & node1 (*system.nodes[0]); - rai::genesis genesis; - auto block1 (std::make_shared (genesis.hash (), 0, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node1.work_generate_blocking (*block1); - ASSERT_EQ (rai::process_result::progress, node1.process (*block1).code); - auto node_l (system.nodes[0]); - node1.active.start (block1); - auto vote (std::make_shared (rai::test_genesis_key.pub, rai::test_genesis_key.prv, 0, block1)); - rai::confirm_ack con1 (vote); - node1.process_message (con1, node1.network.endpoint ()); -} - -TEST (receivable_processor, send_with_receive) -{ - auto amount (std::numeric_limits::max ()); - rai::system system (24000, 2); - rai::keypair key2; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::block_hash latest1 (system.nodes[0]->latest (rai::test_genesis_key.pub)); - system.wallet (1)->insert_adhoc (key2.prv); - auto block1 (std::make_shared (latest1, key2.pub, amount - system.nodes[0]->config.receive_minimum.number (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (latest1))); - ASSERT_EQ (amount, system.nodes[0]->balance (rai::test_genesis_key.pub)); - ASSERT_EQ (0, system.nodes[0]->balance (key2.pub)); - ASSERT_EQ (amount, system.nodes[1]->balance (rai::test_genesis_key.pub)); - ASSERT_EQ (0, system.nodes[1]->balance (key2.pub)); - system.nodes[0]->process_active (block1); - system.nodes[0]->block_processor.flush (); - system.nodes[1]->process_active (block1); - system.nodes[1]->block_processor.flush (); - ASSERT_EQ (amount - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (rai::test_genesis_key.pub)); - ASSERT_EQ (0, system.nodes[0]->balance (key2.pub)); - ASSERT_EQ (amount - system.nodes[0]->config.receive_minimum.number (), system.nodes[1]->balance (rai::test_genesis_key.pub)); - ASSERT_EQ (0, system.nodes[1]->balance (key2.pub)); - system.deadline_set (10s); - while (system.nodes[0]->balance (key2.pub) != system.nodes[0]->config.receive_minimum.number ()) - { - ASSERT_NO_ERROR (system.poll ()); - } - ASSERT_EQ (amount - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (rai::test_genesis_key.pub)); - ASSERT_EQ (system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (key2.pub)); - ASSERT_EQ (amount - system.nodes[0]->config.receive_minimum.number (), system.nodes[1]->balance (rai::test_genesis_key.pub)); - ASSERT_EQ (system.nodes[0]->config.receive_minimum.number (), system.nodes[1]->balance (key2.pub)); -} - -TEST (network, receive_weight_change) -{ - rai::system system (24000, 2); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key2; - system.wallet (1)->insert_adhoc (key2.prv); - { - auto transaction (system.nodes[1]->store.tx_begin (true)); - system.wallet (1)->store.representative_set (transaction, key2.pub); - } - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); - system.deadline_set (10s); - while (std::any_of (system.nodes.begin (), system.nodes.end (), [&](std::shared_ptr const & node_a) { return node_a->weight (key2.pub) != system.nodes[0]->config.receive_minimum.number (); })) - { - ASSERT_NO_ERROR (system.poll ()); - } -} - -TEST (parse_endpoint, valid) -{ - std::string string ("::1:24000"); - rai::endpoint endpoint; - ASSERT_FALSE (rai::parse_endpoint (string, endpoint)); - ASSERT_EQ (boost::asio::ip::address_v6::loopback (), endpoint.address ()); - ASSERT_EQ (24000, endpoint.port ()); -} - -TEST (parse_endpoint, invalid_port) -{ - std::string string ("::1:24a00"); - rai::endpoint endpoint; - ASSERT_TRUE (rai::parse_endpoint (string, endpoint)); -} - -TEST (parse_endpoint, invalid_address) -{ - std::string string ("::q:24000"); - rai::endpoint endpoint; - ASSERT_TRUE (rai::parse_endpoint (string, endpoint)); -} - -TEST (parse_endpoint, no_address) -{ - std::string string (":24000"); - rai::endpoint endpoint; - ASSERT_TRUE (rai::parse_endpoint (string, endpoint)); -} - -TEST (parse_endpoint, no_port) -{ - std::string string ("::1:"); - rai::endpoint endpoint; - ASSERT_TRUE (rai::parse_endpoint (string, endpoint)); -} - -TEST (parse_endpoint, no_colon) -{ - std::string string ("::1"); - rai::endpoint endpoint; - ASSERT_TRUE (rai::parse_endpoint (string, endpoint)); -} - -// If the account doesn't exist, current == end so there's no iteration -TEST (bulk_pull, no_address) -{ - rai::system system (24000, 1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - std::unique_ptr req (new rai::bulk_pull); - req->start = 1; - req->end = 2; - connection->requests.push (std::unique_ptr{}); - auto request (std::make_shared (connection, std::move (req))); - ASSERT_EQ (request->current, request->request->end); - ASSERT_TRUE (request->current.is_zero ()); -} - -TEST (bulk_pull, genesis_to_end) -{ - rai::system system (24000, 1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - std::unique_ptr req (new rai::bulk_pull{}); - req->start = rai::test_genesis_key.pub; - req->end.clear (); - connection->requests.push (std::unique_ptr{}); - auto request (std::make_shared (connection, std::move (req))); - ASSERT_EQ (system.nodes[0]->latest (rai::test_genesis_key.pub), request->current); - ASSERT_EQ (request->request->end, request->request->end); -} - -// If we can't find the end block, send everything -TEST (bulk_pull, no_end) -{ - rai::system system (24000, 1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - std::unique_ptr req (new rai::bulk_pull{}); - req->start = rai::test_genesis_key.pub; - req->end = 1; - connection->requests.push (std::unique_ptr{}); - auto request (std::make_shared (connection, std::move (req))); - ASSERT_EQ (system.nodes[0]->latest (rai::test_genesis_key.pub), request->current); - ASSERT_TRUE (request->request->end.is_zero ()); -} - -TEST (bulk_pull, end_not_owned) -{ - rai::system system (24000, 1); - rai::keypair key2; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, 100)); - rai::block_hash latest (system.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::open_block open (0, 1, 2, rai::keypair ().prv, 4, 5); - open.hashables.account = key2.pub; - open.hashables.representative = key2.pub; - open.hashables.source = latest; - open.signature = rai::sign_message (key2.prv, key2.pub, open.hash ()); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (open).code); - auto connection (std::make_shared (nullptr, system.nodes[0])); - rai::genesis genesis; - std::unique_ptr req (new rai::bulk_pull{}); - req->start = key2.pub; - req->end = genesis.hash (); - connection->requests.push (std::unique_ptr{}); - auto request (std::make_shared (connection, std::move (req))); - ASSERT_EQ (request->current, request->request->end); -} - -TEST (bulk_pull, none) -{ - rai::system system (24000, 1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - rai::genesis genesis; - std::unique_ptr req (new rai::bulk_pull{}); - req->start = rai::test_genesis_key.pub; - req->end = genesis.hash (); - connection->requests.push (std::unique_ptr{}); - auto request (std::make_shared (connection, std::move (req))); - auto block (request->get_next ()); - ASSERT_EQ (nullptr, block); -} - -TEST (bulk_pull, get_next_on_open) -{ - rai::system system (24000, 1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - std::unique_ptr req (new rai::bulk_pull{}); - req->start = rai::test_genesis_key.pub; - req->end.clear (); - connection->requests.push (std::unique_ptr{}); - auto request (std::make_shared (connection, std::move (req))); - auto block (request->get_next ()); - ASSERT_NE (nullptr, block); - ASSERT_TRUE (block->previous ().is_zero ()); - ASSERT_FALSE (connection->requests.empty ()); - ASSERT_EQ (request->current, request->request->end); -} - -TEST (bulk_pull, by_block) -{ - rai::system system (24000, 1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - rai::genesis genesis; - std::unique_ptr req (new rai::bulk_pull{}); - req->start = genesis.hash (); - req->end.clear (); - connection->requests.push (std::unique_ptr{}); - auto request (std::make_shared (connection, std::move (req))); - auto block (request->get_next ()); - ASSERT_NE (nullptr, block); - ASSERT_EQ (block->hash (), genesis.hash ()); - - block = request->get_next (); - ASSERT_EQ (nullptr, block); -} - -TEST (bulk_pull, by_block_single) -{ - rai::system system (24000, 1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - rai::genesis genesis; - std::unique_ptr req (new rai::bulk_pull{}); - req->start = genesis.hash (); - req->end = genesis.hash (); - connection->requests.push (std::unique_ptr{}); - auto request (std::make_shared (connection, std::move (req))); - auto block (request->get_next ()); - ASSERT_NE (nullptr, block); - ASSERT_EQ (block->hash (), genesis.hash ()); - - block = request->get_next (); - ASSERT_EQ (nullptr, block); -} - -TEST (bulk_pull, count_limit) -{ - rai::system system (24000, 1); - rai::genesis genesis; - - auto send1 (std::make_shared (system.nodes[0]->latest (rai::test_genesis_key.pub), rai::test_genesis_key.pub, 1, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (system.nodes[0]->latest (rai::test_genesis_key.pub)))); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (*send1).code); - auto receive1 (std::make_shared (send1->hash (), send1->hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (send1->hash ()))); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (*receive1).code); - - auto connection (std::make_shared (nullptr, system.nodes[0])); - std::unique_ptr req (new rai::bulk_pull{}); - req->start = receive1->hash (); - req->set_count_present (true); - req->count = 2; - connection->requests.push (std::unique_ptr{}); - auto request (std::make_shared (connection, std::move (req))); - - ASSERT_EQ (request->max_count, 2); - ASSERT_EQ (request->sent_count, 0); - - auto block (request->get_next ()); - ASSERT_EQ (receive1->hash (), block->hash ()); - - block = request->get_next (); - ASSERT_EQ (send1->hash (), block->hash ()); - - block = request->get_next (); - ASSERT_EQ (nullptr, block); -} - -TEST (bootstrap_processor, DISABLED_process_none) -{ - rai::system system (24000, 1); - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); - auto done (false); - node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); - while (!done) - { - system.io_ctx.run_one (); - } - node1->stop (); -} - -// Bootstrap can pull one basic block -TEST (bootstrap_processor, process_one) -{ - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, rai::test_genesis_key.pub, 100)); - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); - rai::block_hash hash1 (system.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::block_hash hash2 (node1->latest (rai::test_genesis_key.pub)); - ASSERT_NE (hash1, hash2); - node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); - ASSERT_NE (node1->latest (rai::test_genesis_key.pub), system.nodes[0]->latest (rai::test_genesis_key.pub)); - system.deadline_set (10s); - while (node1->latest (rai::test_genesis_key.pub) != system.nodes[0]->latest (rai::test_genesis_key.pub)) - { - ASSERT_NO_ERROR (system.poll ()); - } - ASSERT_EQ (0, node1->active.roots.size ()); - node1->stop (); -} - -TEST (bootstrap_processor, process_two) -{ - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::block_hash hash1 (system.nodes[0]->latest (rai::test_genesis_key.pub)); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, rai::test_genesis_key.pub, 50)); - rai::block_hash hash2 (system.nodes[0]->latest (rai::test_genesis_key.pub)); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, rai::test_genesis_key.pub, 50)); - rai::block_hash hash3 (system.nodes[0]->latest (rai::test_genesis_key.pub)); - ASSERT_NE (hash1, hash2); - ASSERT_NE (hash1, hash3); - ASSERT_NE (hash2, hash3); - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); - node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); - ASSERT_NE (node1->latest (rai::test_genesis_key.pub), system.nodes[0]->latest (rai::test_genesis_key.pub)); - system.deadline_set (10s); - while (node1->latest (rai::test_genesis_key.pub) != system.nodes[0]->latest (rai::test_genesis_key.pub)) - { - ASSERT_NO_ERROR (system.poll ()); - } - node1->stop (); -} - -// Bootstrap can pull universal blocks -TEST (bootstrap_processor, process_state) -{ - rai::system system (24000, 1); - rai::genesis genesis; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - auto node0 (system.nodes[0]); - auto block1 (std::make_shared (rai::test_genesis_key.pub, node0->latest (rai::test_genesis_key.pub), rai::test_genesis_key.pub, rai::genesis_amount - 100, rai::test_genesis_key.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - auto block2 (std::make_shared (rai::test_genesis_key.pub, block1->hash (), rai::test_genesis_key.pub, rai::genesis_amount, block1->hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0)); - node0->work_generate_blocking (*block1); - node0->work_generate_blocking (*block2); - node0->process (*block1); - node0->process (*block2); - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_EQ (node0->latest (rai::test_genesis_key.pub), block2->hash ()); - ASSERT_NE (node1->latest (rai::test_genesis_key.pub), block2->hash ()); - node1->bootstrap_initiator.bootstrap (node0->network.endpoint ()); - ASSERT_NE (node1->latest (rai::test_genesis_key.pub), node0->latest (rai::test_genesis_key.pub)); - system.deadline_set (10s); - while (node1->latest (rai::test_genesis_key.pub) != node0->latest (rai::test_genesis_key.pub)) - { - ASSERT_NO_ERROR (system.poll ()); - } - ASSERT_EQ (0, node1->active.roots.size ()); - node1->stop (); -} - -TEST (bootstrap_processor, process_new) -{ - rai::system system (24000, 2); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::keypair key2; - system.wallet (1)->insert_adhoc (key2.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); - system.deadline_set (10s); - while (system.nodes[0]->balance (key2.pub).is_zero ()) - { - ASSERT_NO_ERROR (system.poll ()); - } - rai::uint128_t balance1 (system.nodes[0]->balance (rai::test_genesis_key.pub)); - rai::uint128_t balance2 (system.nodes[0]->balance (key2.pub)); - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24002, rai::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); - node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); - system.deadline_set (10s); - while (node1->balance (key2.pub) != balance2) - { - ASSERT_NO_ERROR (system.poll ()); - } - ASSERT_EQ (balance1, node1->balance (rai::test_genesis_key.pub)); - node1->stop (); -} - -TEST (bootstrap_processor, pull_diamond) -{ - rai::system system (24000, 1); - rai::keypair key; - auto send1 (std::make_shared (system.nodes[0]->latest (rai::test_genesis_key.pub), key.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (system.nodes[0]->latest (rai::test_genesis_key.pub)))); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (*send1).code); - auto open (std::make_shared (send1->hash (), 1, key.pub, key.prv, key.pub, system.work.generate (key.pub))); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (*open).code); - auto send2 (std::make_shared (open->hash (), rai::test_genesis_key.pub, std::numeric_limits::max () - 100, key.prv, key.pub, system.work.generate (open->hash ()))); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (*send2).code); - auto receive (std::make_shared (send1->hash (), send2->hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (send1->hash ()))); - ASSERT_EQ (rai::process_result::progress, system.nodes[0]->process (*receive).code); - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24002, rai::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); - node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); - system.deadline_set (10s); - while (node1->balance (rai::test_genesis_key.pub) != 100) - { - ASSERT_NO_ERROR (system.poll ()); - } - ASSERT_EQ (100, node1->balance (rai::test_genesis_key.pub)); - node1->stop (); -} - -TEST (bootstrap_processor, push_diamond) -{ - rai::system system (24000, 1); - rai::keypair key; - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24002, rai::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); - auto wallet1 (node1->wallets.create (100)); - wallet1->insert_adhoc (rai::test_genesis_key.prv); - wallet1->insert_adhoc (key.prv); - auto send1 (std::make_shared (system.nodes[0]->latest (rai::test_genesis_key.pub), key.pub, 0, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (system.nodes[0]->latest (rai::test_genesis_key.pub)))); - ASSERT_EQ (rai::process_result::progress, node1->process (*send1).code); - auto open (std::make_shared (send1->hash (), 1, key.pub, key.prv, key.pub, system.work.generate (key.pub))); - ASSERT_EQ (rai::process_result::progress, node1->process (*open).code); - auto send2 (std::make_shared (open->hash (), rai::test_genesis_key.pub, std::numeric_limits::max () - 100, key.prv, key.pub, system.work.generate (open->hash ()))); - ASSERT_EQ (rai::process_result::progress, node1->process (*send2).code); - auto receive (std::make_shared (send1->hash (), send2->hash (), rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.work.generate (send1->hash ()))); - ASSERT_EQ (rai::process_result::progress, node1->process (*receive).code); - node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); - system.deadline_set (10s); - while (system.nodes[0]->balance (rai::test_genesis_key.pub) != 100) - { - ASSERT_NO_ERROR (system.poll ()); - } - ASSERT_EQ (100, system.nodes[0]->balance (rai::test_genesis_key.pub)); - node1->stop (); -} - -TEST (bootstrap_processor, push_one) -{ - rai::system system (24000, 1); - rai::node_init init1; - rai::keypair key1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); - auto wallet (node1->wallets.create (rai::uint256_union ())); - ASSERT_NE (nullptr, wallet); - wallet->insert_adhoc (rai::test_genesis_key.prv); - rai::uint128_t balance1 (node1->balance (rai::test_genesis_key.pub)); - ASSERT_NE (nullptr, wallet->send_action (rai::test_genesis_key.pub, key1.pub, 100)); - ASSERT_NE (balance1, node1->balance (rai::test_genesis_key.pub)); - node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); - system.deadline_set (10s); - while (system.nodes[0]->balance (rai::test_genesis_key.pub) == balance1) - { - ASSERT_NO_ERROR (system.poll ()); - } - node1->stop (); -} - -TEST (bootstrap_processor, lazy_hash) -{ - rai::system system (24000, 1); - rai::node_init init1; - rai::genesis genesis; - rai::keypair key1; - rai::keypair key2; - // Generating test chain - auto send1 (std::make_shared (rai::test_genesis_key.pub, genesis.hash (), rai::test_genesis_key.pub, rai::genesis_amount - rai::Gxrb_ratio, key1.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.nodes[0]->work_generate_blocking (genesis.hash ()))); - auto receive1 (std::make_shared (key1.pub, 0, key1.pub, rai::Gxrb_ratio, send1->hash (), key1.prv, key1.pub, system.nodes[0]->work_generate_blocking (key1.pub))); - auto send2 (std::make_shared (key1.pub, receive1->hash (), key1.pub, 0, key2.pub, key1.prv, key1.pub, system.nodes[0]->work_generate_blocking (receive1->hash ()))); - auto receive2 (std::make_shared (key2.pub, 0, key2.pub, rai::Gxrb_ratio, send2->hash (), key2.prv, key2.pub, system.nodes[0]->work_generate_blocking (key2.pub))); - // Processing test chain - system.nodes[0]->block_processor.add (send1, std::chrono::steady_clock::time_point ()); - system.nodes[0]->block_processor.add (receive1, std::chrono::steady_clock::time_point ()); - system.nodes[0]->block_processor.add (send2, std::chrono::steady_clock::time_point ()); - system.nodes[0]->block_processor.add (receive2, std::chrono::steady_clock::time_point ()); - system.nodes[0]->block_processor.flush (); - // Start lazy bootstrap with last block in chain known - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); - node1->peers.insert (system.nodes[0]->network.endpoint (), rai::protocol_version); - node1->bootstrap_initiator.bootstrap_lazy (receive2->hash ()); - // Check processed blocks - system.deadline_set (10s); - while (node1->balance (key2.pub) == 0) - { - ASSERT_NO_ERROR (system.poll ()); - } - node1->stop (); -} - -TEST (bootstrap_processor, lazy_max_pull_count) -{ - rai::system system (24000, 1); - rai::node_init init1; - rai::genesis genesis; - rai::keypair key1; - rai::keypair key2; - // Generating test chain - auto send1 (std::make_shared (rai::test_genesis_key.pub, genesis.hash (), rai::test_genesis_key.pub, rai::genesis_amount - rai::Gxrb_ratio, key1.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, system.nodes[0]->work_generate_blocking (genesis.hash ()))); - auto receive1 (std::make_shared (key1.pub, 0, key1.pub, rai::Gxrb_ratio, send1->hash (), key1.prv, key1.pub, system.nodes[0]->work_generate_blocking (key1.pub))); - auto send2 (std::make_shared (key1.pub, receive1->hash (), key1.pub, 0, key2.pub, key1.prv, key1.pub, system.nodes[0]->work_generate_blocking (receive1->hash ()))); - auto receive2 (std::make_shared (key2.pub, 0, key2.pub, rai::Gxrb_ratio, send2->hash (), key2.prv, key2.pub, system.nodes[0]->work_generate_blocking (key2.pub))); - auto change1 (std::make_shared (key2.pub, receive2->hash (), key1.pub, rai::Gxrb_ratio, 0, key2.prv, key2.pub, system.nodes[0]->work_generate_blocking (receive2->hash ()))); - auto change2 (std::make_shared (key2.pub, change1->hash (), rai::test_genesis_key.pub, rai::Gxrb_ratio, 0, key2.prv, key2.pub, system.nodes[0]->work_generate_blocking (change1->hash ()))); - auto change3 (std::make_shared (key2.pub, change2->hash (), key2.pub, rai::Gxrb_ratio, 0, key2.prv, key2.pub, system.nodes[0]->work_generate_blocking (change2->hash ()))); - // Processing test chain - system.nodes[0]->block_processor.add (send1, std::chrono::steady_clock::time_point ()); - system.nodes[0]->block_processor.add (receive1, std::chrono::steady_clock::time_point ()); - system.nodes[0]->block_processor.add (send2, std::chrono::steady_clock::time_point ()); - system.nodes[0]->block_processor.add (receive2, std::chrono::steady_clock::time_point ()); - system.nodes[0]->block_processor.add (change1, std::chrono::steady_clock::time_point ()); - system.nodes[0]->block_processor.add (change2, std::chrono::steady_clock::time_point ()); - system.nodes[0]->block_processor.add (change3, std::chrono::steady_clock::time_point ()); - system.nodes[0]->block_processor.flush (); - // Start lazy bootstrap with last block in chain known - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); - node1->peers.insert (system.nodes[0]->network.endpoint (), rai::protocol_version); - node1->bootstrap_initiator.bootstrap_lazy (change3->hash ()); - // Check processed blocks - system.deadline_set (10s); - while (node1->block (change3->hash ()) == nullptr) - { - ASSERT_NO_ERROR (system.poll ()); - } - node1->stop (); -} - -TEST (frontier_req_response, DISABLED_destruction) -{ - { - std::shared_ptr hold; // Destructing tcp acceptor on non-existent io_context - { - rai::system system (24000, 1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - std::unique_ptr req (new rai::frontier_req); - req->start.clear (); - req->age = std::numeric_limitsage)>::max (); - req->count = std::numeric_limitscount)>::max (); - connection->requests.push (std::unique_ptr{}); - hold = std::make_shared (connection, std::move (req)); - } - } - ASSERT_TRUE (true); -} - -TEST (frontier_req, begin) -{ - rai::system system (24000, 1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - std::unique_ptr req (new rai::frontier_req); - req->start.clear (); - req->age = std::numeric_limitsage)>::max (); - req->count = std::numeric_limitscount)>::max (); - connection->requests.push (std::unique_ptr{}); - auto request (std::make_shared (connection, std::move (req))); - ASSERT_EQ (rai::test_genesis_key.pub, request->current); - rai::genesis genesis; - ASSERT_EQ (genesis.hash (), request->frontier); -} - -TEST (frontier_req, end) -{ - rai::system system (24000, 1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - std::unique_ptr req (new rai::frontier_req); - req->start = rai::test_genesis_key.pub.number () + 1; - req->age = std::numeric_limitsage)>::max (); - req->count = std::numeric_limitscount)>::max (); - connection->requests.push (std::unique_ptr{}); - auto request (std::make_shared (connection, std::move (req))); - ASSERT_TRUE (request->current.is_zero ()); -} - -TEST (frontier_req, count) -{ - rai::system system (24000, 1); - auto & node1 (*system.nodes[0]); - rai::genesis genesis; - // Public key FB93... after genesis in accounts table - rai::keypair key1 ("ED5AE0A6505B14B67435C29FD9FEEBC26F597D147BC92F6D795FFAD7AFD3D967"); - rai::state_block send1 (rai::test_genesis_key.pub, genesis.hash (), rai::test_genesis_key.pub, rai::genesis_amount - rai::Gxrb_ratio, key1.pub, rai::test_genesis_key.prv, rai::test_genesis_key.pub, 0); - node1.work_generate_blocking (send1); - ASSERT_EQ (rai::process_result::progress, node1.process (send1).code); - rai::state_block receive1 (key1.pub, 0, rai::test_genesis_key.pub, rai::Gxrb_ratio, send1.hash (), key1.prv, key1.pub, 0); - node1.work_generate_blocking (receive1); - ASSERT_EQ (rai::process_result::progress, node1.process (receive1).code); - auto connection (std::make_shared (nullptr, system.nodes[0])); - std::unique_ptr req (new rai::frontier_req); - req->start.clear (); - req->age = std::numeric_limitsage)>::max (); - req->count = 1; - connection->requests.push (std::unique_ptr{}); - auto request (std::make_shared (connection, std::move (req))); - ASSERT_EQ (rai::test_genesis_key.pub, request->current); - ASSERT_EQ (send1.hash (), request->frontier); -} - -TEST (frontier_req, time_bound) -{ - rai::system system (24000, 1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - std::unique_ptr req (new rai::frontier_req); - req->start.clear (); - req->age = 0; - req->count = std::numeric_limitscount)>::max (); - connection->requests.push (std::unique_ptr{}); - auto request (std::make_shared (connection, std::move (req))); - ASSERT_EQ (rai::test_genesis_key.pub, request->current); - // Wait for next second when age of account will be > 0 seconds - std::this_thread::sleep_for (std::chrono::milliseconds (1001)); - std::unique_ptr req2 (new rai::frontier_req); - req2->start.clear (); - req2->age = 0; - req2->count = std::numeric_limitscount)>::max (); - auto connection2 (std::make_shared (nullptr, system.nodes[0])); - connection2->requests.push (std::unique_ptr{}); - auto request2 (std::make_shared (connection, std::move (req2))); - ASSERT_TRUE (request2->current.is_zero ()); -} - -TEST (frontier_req, time_cutoff) -{ - rai::system system (24000, 1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - std::unique_ptr req (new rai::frontier_req); - req->start.clear (); - req->age = 3; - req->count = std::numeric_limitscount)>::max (); - connection->requests.push (std::unique_ptr{}); - auto request (std::make_shared (connection, std::move (req))); - ASSERT_EQ (rai::test_genesis_key.pub, request->current); - rai::genesis genesis; - ASSERT_EQ (genesis.hash (), request->frontier); - // Wait 4 seconds when age of account will be > 3 seconds - std::this_thread::sleep_for (std::chrono::milliseconds (4001)); - std::unique_ptr req2 (new rai::frontier_req); - req2->start.clear (); - req2->age = 3; - req2->count = std::numeric_limitscount)>::max (); - auto connection2 (std::make_shared (nullptr, system.nodes[0])); - connection2->requests.push (std::unique_ptr{}); - auto request2 (std::make_shared (connection, std::move (req2))); - ASSERT_TRUE (request2->frontier.is_zero ()); -} - -TEST (bulk, genesis) -{ - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); - rai::block_hash latest1 (system.nodes[0]->latest (rai::test_genesis_key.pub)); - rai::block_hash latest2 (node1->latest (rai::test_genesis_key.pub)); - ASSERT_EQ (latest1, latest2); - rai::keypair key2; - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, 100)); - rai::block_hash latest3 (system.nodes[0]->latest (rai::test_genesis_key.pub)); - ASSERT_NE (latest1, latest3); - node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); - system.deadline_set (10s); - while (node1->latest (rai::test_genesis_key.pub) != system.nodes[0]->latest (rai::test_genesis_key.pub)) - { - ASSERT_NO_ERROR (system.poll ()); - } - ASSERT_EQ (node1->latest (rai::test_genesis_key.pub), system.nodes[0]->latest (rai::test_genesis_key.pub)); - node1->stop (); -} - -TEST (bulk, offline_send) -{ - rai::system system (24000, 1); - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - rai::node_init init1; - auto node1 (std::make_shared (init1, system.io_ctx, 24001, rai::unique_path (), system.alarm, system.logging, system.work)); - ASSERT_FALSE (init1.error ()); - node1->start (); - system.nodes.push_back (node1); - rai::keypair key2; - auto wallet (node1->wallets.create (rai::uint256_union ())); - wallet->insert_adhoc (key2.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (rai::test_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); - ASSERT_NE (std::numeric_limits::max (), system.nodes[0]->balance (rai::test_genesis_key.pub)); - // Wait to finish election background tasks - system.deadline_set (10s); - while (!system.nodes[0]->active.roots.empty ()) - { - ASSERT_NO_ERROR (system.poll ()); - } - // Initiate bootstrap - node1->bootstrap_initiator.bootstrap (system.nodes[0]->network.endpoint ()); - // Nodes should find each other - do - { - ASSERT_NO_ERROR (system.poll ()); - } while (system.nodes[0]->peers.empty () || node1->peers.empty ()); - // Send block arrival via bootstrap - while (node1->balance (rai::test_genesis_key.pub) == std::numeric_limits::max ()) - { - ASSERT_NO_ERROR (system.poll ()); - } - // Receiving send block - system.deadline_set (20s); - while (node1->balance (key2.pub) != system.nodes[0]->config.receive_minimum.number ()) - { - ASSERT_NO_ERROR (system.poll ()); - } - node1->stop (); -} - -TEST (network, ipv6) -{ - boost::asio::ip::address_v6 address (boost::asio::ip::address_v6::from_string ("::ffff:127.0.0.1")); - ASSERT_TRUE (address.is_v4_mapped ()); - rai::endpoint endpoint1 (address, 16384); - std::vector bytes1; - { - rai::vectorstream stream (bytes1); - rai::write (stream, address.to_bytes ()); - } - ASSERT_EQ (16, bytes1.size ()); - for (auto i (bytes1.begin ()), n (bytes1.begin () + 10); i != n; ++i) - { - ASSERT_EQ (0, *i); - } - ASSERT_EQ (0xff, bytes1[10]); - ASSERT_EQ (0xff, bytes1[11]); - std::array bytes2; - rai::bufferstream stream (bytes1.data (), bytes1.size ()); - rai::read (stream, bytes2); - rai::endpoint endpoint2 (boost::asio::ip::address_v6 (bytes2), 16384); - ASSERT_EQ (endpoint1, endpoint2); -} - -TEST (network, ipv6_from_ipv4) -{ - rai::endpoint endpoint1 (boost::asio::ip::address_v4::loopback (), 16000); - ASSERT_TRUE (endpoint1.address ().is_v4 ()); - rai::endpoint endpoint2 (boost::asio::ip::address_v6::v4_mapped (endpoint1.address ().to_v4 ()), 16000); - ASSERT_TRUE (endpoint2.address ().is_v6 ()); -} - -TEST (network, ipv6_bind_send_ipv4) -{ - boost::asio::io_context io_ctx; - rai::endpoint endpoint1 (boost::asio::ip::address_v6::any (), 24000); - rai::endpoint endpoint2 (boost::asio::ip::address_v4::any (), 24001); - std::array bytes1; - auto finish1 (false); - rai::endpoint endpoint3; - boost::asio::ip::udp::socket socket1 (io_ctx, endpoint1); - socket1.async_receive_from (boost::asio::buffer (bytes1.data (), bytes1.size ()), endpoint3, [&finish1](boost::system::error_code const & error, size_t size_a) { - ASSERT_FALSE (error); - ASSERT_EQ (16, size_a); - finish1 = true; - }); - boost::asio::ip::udp::socket socket2 (io_ctx, endpoint2); - rai::endpoint endpoint5 (boost::asio::ip::address_v4::loopback (), 24000); - rai::endpoint endpoint6 (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4::loopback ()), 24001); - socket2.async_send_to (boost::asio::buffer (std::array{}, 16), endpoint5, [](boost::system::error_code const & error, size_t size_a) { - ASSERT_FALSE (error); - ASSERT_EQ (16, size_a); - }); - auto iterations (0); - while (!finish1) - { - io_ctx.poll (); - ++iterations; - ASSERT_LT (iterations, 200); - } - ASSERT_EQ (endpoint6, endpoint3); - std::array bytes2; - rai::endpoint endpoint4; - socket2.async_receive_from (boost::asio::buffer (bytes2.data (), bytes2.size ()), endpoint4, [](boost::system::error_code const & error, size_t size_a) { - ASSERT_FALSE (!error); - ASSERT_EQ (16, size_a); - }); - socket1.async_send_to (boost::asio::buffer (std::array{}, 16), endpoint6, [](boost::system::error_code const & error, size_t size_a) { - ASSERT_FALSE (error); - ASSERT_EQ (16, size_a); - }); -} - -TEST (network, endpoint_bad_fd) -{ - rai::system system (24000, 1); - system.nodes[0]->stop (); - auto endpoint (system.nodes[0]->network.endpoint ()); - ASSERT_TRUE (endpoint.address ().is_loopback ()); - ASSERT_EQ (0, endpoint.port ()); -} - -TEST (network, reserved_address) -{ - ASSERT_FALSE (rai::reserved_address (rai::endpoint (boost::asio::ip::address_v6::from_string ("2001::"), 0), true)); - rai::endpoint loopback (boost::asio::ip::address_v6::from_string ("::1"), 1); - ASSERT_FALSE (rai::reserved_address (loopback, false)); - ASSERT_TRUE (rai::reserved_address (loopback, true)); -} - -TEST (node, port_mapping) -{ - rai::system system (24000, 1); - auto node0 (system.nodes[0]); - node0->port_mapping.refresh_devices (); - node0->port_mapping.start (); - auto end (std::chrono::steady_clock::now () + std::chrono::seconds (500)); - (void)end; - //while (std::chrono::steady_clock::now () < end) - { - ASSERT_NO_ERROR (system.poll ()); - } -} - -TEST (udp_buffer, one_buffer) -{ - rai::stat stats; - rai::udp_buffer buffer (stats, 512, 1); - auto buffer1 (buffer.allocate ()); - ASSERT_NE (nullptr, buffer1); - buffer.enqueue (buffer1); - auto buffer2 (buffer.dequeue ()); - ASSERT_EQ (buffer1, buffer2); - buffer.release (buffer2); - auto buffer3 (buffer.allocate ()); - ASSERT_EQ (buffer1, buffer3); -} - -TEST (udp_buffer, two_buffers) -{ - rai::stat stats; - rai::udp_buffer buffer (stats, 512, 2); - auto buffer1 (buffer.allocate ()); - ASSERT_NE (nullptr, buffer1); - auto buffer2 (buffer.allocate ()); - ASSERT_NE (nullptr, buffer2); - ASSERT_NE (buffer1, buffer2); - buffer.enqueue (buffer2); - buffer.enqueue (buffer1); - auto buffer3 (buffer.dequeue ()); - ASSERT_EQ (buffer2, buffer3); - auto buffer4 (buffer.dequeue ()); - ASSERT_EQ (buffer1, buffer4); - buffer.release (buffer3); - buffer.release (buffer4); - auto buffer5 (buffer.allocate ()); - ASSERT_EQ (buffer2, buffer5); - auto buffer6 (buffer.allocate ()); - ASSERT_EQ (buffer1, buffer6); -} - -TEST (udp_buffer, one_overflow) -{ - rai::stat stats; - rai::udp_buffer buffer (stats, 512, 1); - auto buffer1 (buffer.allocate ()); - ASSERT_NE (nullptr, buffer1); - buffer.enqueue (buffer1); - auto buffer2 (buffer.allocate ()); - ASSERT_EQ (buffer1, buffer2); -} - -TEST (udp_buffer, two_overflow) -{ - rai::stat stats; - rai::udp_buffer buffer (stats, 512, 2); - auto buffer1 (buffer.allocate ()); - ASSERT_NE (nullptr, buffer1); - buffer.enqueue (buffer1); - auto buffer2 (buffer.allocate ()); - ASSERT_NE (nullptr, buffer2); - ASSERT_NE (buffer1, buffer2); - buffer.enqueue (buffer2); - auto buffer3 (buffer.allocate ()); - ASSERT_EQ (buffer1, buffer3); - auto buffer4 (buffer.allocate ()); - ASSERT_EQ (buffer2, buffer4); -} - -TEST (udp_buffer, one_buffer_multithreaded) -{ - rai::stat stats; - rai::udp_buffer buffer (stats, 512, 1); - boost::thread thread ([&buffer]() { - auto done (false); - while (!done) - { - auto item (buffer.dequeue ()); - done = item == nullptr; - if (item != nullptr) - { - buffer.release (item); - } - } - }); - auto buffer1 (buffer.allocate ()); - ASSERT_NE (nullptr, buffer1); - buffer.enqueue (buffer1); - auto buffer2 (buffer.allocate ()); - ASSERT_EQ (buffer1, buffer2); - buffer.stop (); - thread.join (); -} - -TEST (udp_buffer, many_buffers_multithreaded) -{ - rai::stat stats; - rai::udp_buffer buffer (stats, 512, 16); - std::vector threads; - for (auto i (0); i < 4; ++i) - { - threads.push_back (boost::thread ([&buffer]() { - auto done (false); - while (!done) - { - auto item (buffer.dequeue ()); - done = item == nullptr; - if (item != nullptr) - { - buffer.release (item); - } - } - })); - } - std::atomic_int count (0); - for (auto i (0); i < 4; ++i) - { - threads.push_back (boost::thread ([&buffer, &count]() { - auto done (false); - for (auto i (0); !done && i < 1000; ++i) - { - auto item (buffer.allocate ()); - done = item == nullptr; - if (item != nullptr) - { - buffer.enqueue (item); - ++count; - if (count > 3000) - { - buffer.stop (); - } - } - } - })); - } - buffer.stop (); - for (auto & i : threads) - { - i.join (); - } -} - -TEST (udp_buffer, stats) -{ - rai::stat stats; - rai::udp_buffer buffer (stats, 512, 1); - auto buffer1 (buffer.allocate ()); - buffer.enqueue (buffer1); - buffer.allocate (); - ASSERT_EQ (1, stats.count (rai::stat::type::udp, rai::stat::detail::overflow)); -} - -TEST (bulk_pull_account, basics) -{ - rai::system system (24000, 1); - system.nodes[0]->config.receive_minimum = rai::uint128_union (20); - rai::keypair key1; - system.wallet (0)->insert_adhoc (rai::test_genesis_key.prv); - system.wallet (0)->insert_adhoc (key1.prv); - auto send1 (system.wallet (0)->send_action (rai::genesis_account, key1.pub, 25)); - auto send2 (system.wallet (0)->send_action (rai::genesis_account, key1.pub, 10)); - auto send3 (system.wallet (0)->send_action (rai::genesis_account, key1.pub, 2)); - system.deadline_set (5s); - while (system.nodes[0]->balance (key1.pub) != 25) - { - ASSERT_NO_ERROR (system.poll ()); - } - auto connection (std::make_shared (nullptr, system.nodes[0])); - std::unique_ptr req (new rai::bulk_pull_account{}); - req->account = key1.pub; - req->minimum_amount = 5; - req->flags = rai::bulk_pull_account_flags (); - connection->requests.push (std::unique_ptr{}); - auto request (std::make_shared (connection, std::move (req))); - ASSERT_FALSE (request->invalid_request); - ASSERT_FALSE (request->pending_include_address); - ASSERT_FALSE (request->pending_address_only); - ASSERT_EQ (request->current_key.account, key1.pub); - ASSERT_EQ (request->current_key.hash, 0); - auto block_data (request->get_next ()); - ASSERT_EQ (send2->hash (), block_data.first.get ()->hash); - ASSERT_EQ (rai::uint128_union (10), block_data.second.get ()->amount); - ASSERT_EQ (rai::genesis_account, block_data.second.get ()->source); - ASSERT_EQ (nullptr, request->get_next ().first.get ()); -} diff --git a/rai/core_test/peer_container.cpp b/rai/core_test/peer_container.cpp deleted file mode 100644 index dd577817..00000000 --- a/rai/core_test/peer_container.cpp +++ /dev/null @@ -1,171 +0,0 @@ -#include -#include - -TEST (peer_container, empty_peers) -{ - rai::peer_container peers (rai::endpoint{}); - auto list (peers.purge_list (std::chrono::steady_clock::now ())); - ASSERT_EQ (0, list.size ()); -} - -TEST (peer_container, no_recontact) -{ - rai::peer_container peers (rai::endpoint{}); - auto observed_peer (0); - auto observed_disconnect (false); - rai::endpoint endpoint1 (boost::asio::ip::address_v6::loopback (), 10000); - ASSERT_EQ (0, peers.size ()); - peers.peer_observer = [&observed_peer](rai::endpoint const &) { ++observed_peer; }; - peers.disconnect_observer = [&observed_disconnect]() { observed_disconnect = true; }; - ASSERT_FALSE (peers.insert (endpoint1, rai::protocol_version)); - ASSERT_EQ (1, peers.size ()); - ASSERT_TRUE (peers.insert (endpoint1, rai::protocol_version)); - auto remaining (peers.purge_list (std::chrono::steady_clock::now () + std::chrono::seconds (5))); - ASSERT_TRUE (remaining.empty ()); - ASSERT_EQ (1, observed_peer); - ASSERT_TRUE (observed_disconnect); -} - -TEST (peer_container, no_self_incoming) -{ - rai::endpoint self (boost::asio::ip::address_v6::loopback (), 10000); - rai::peer_container peers (self); - peers.insert (self, 0); - ASSERT_TRUE (peers.peers.empty ()); -} - -TEST (peer_container, no_self_contacting) -{ - rai::endpoint self (boost::asio::ip::address_v6::loopback (), 10000); - rai::peer_container peers (self); - peers.insert (self, 0); - ASSERT_TRUE (peers.peers.empty ()); -} - -TEST (peer_container, reserved_peers_no_contact) -{ - rai::peer_container peers (rai::endpoint{}); - ASSERT_TRUE (peers.insert (rai::endpoint (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0x00000001)), 10000), 0)); - ASSERT_TRUE (peers.insert (rai::endpoint (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0xc0000201)), 10000), 0)); - ASSERT_TRUE (peers.insert (rai::endpoint (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0xc6336401)), 10000), 0)); - ASSERT_TRUE (peers.insert (rai::endpoint (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0xcb007101)), 10000), 0)); - ASSERT_TRUE (peers.insert (rai::endpoint (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0xe9fc0001)), 10000), 0)); - ASSERT_TRUE (peers.insert (rai::endpoint (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0xf0000001)), 10000), 0)); - ASSERT_TRUE (peers.insert (rai::endpoint (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0xffffffff)), 10000), 0)); - ASSERT_EQ (0, peers.size ()); -} - -TEST (peer_container, split) -{ - rai::peer_container peers (rai::endpoint{}); - auto now (std::chrono::steady_clock::now ()); - rai::endpoint endpoint1 (boost::asio::ip::address_v6::any (), 100); - rai::endpoint endpoint2 (boost::asio::ip::address_v6::any (), 101); - peers.peers.insert (rai::peer_information (endpoint1, now - std::chrono::seconds (1), now)); - peers.peers.insert (rai::peer_information (endpoint2, now + std::chrono::seconds (1), now)); - ASSERT_EQ (2, peers.peers.size ()); - auto list (peers.purge_list (now)); - ASSERT_EQ (1, peers.peers.size ()); - ASSERT_EQ (1, list.size ()); - ASSERT_EQ (endpoint2, list[0].endpoint); -} - -TEST (peer_container, fill_random_clear) -{ - rai::peer_container peers (rai::endpoint{}); - std::array target; - std::fill (target.begin (), target.end (), rai::endpoint (boost::asio::ip::address_v6::loopback (), 10000)); - peers.random_fill (target); - ASSERT_TRUE (std::all_of (target.begin (), target.end (), [](rai::endpoint const & endpoint_a) { return endpoint_a == rai::endpoint (boost::asio::ip::address_v6::any (), 0); })); -} - -TEST (peer_container, fill_random_full) -{ - rai::peer_container peers (rai::endpoint{}); - for (auto i (0); i < 100; ++i) - { - peers.insert (rai::endpoint (boost::asio::ip::address_v6::loopback (), i), 0); - } - std::array target; - std::fill (target.begin (), target.end (), rai::endpoint (boost::asio::ip::address_v6::loopback (), 10000)); - peers.random_fill (target); - ASSERT_TRUE (std::none_of (target.begin (), target.end (), [](rai::endpoint const & endpoint_a) { return endpoint_a == rai::endpoint (boost::asio::ip::address_v6::loopback (), 10000); })); -} - -TEST (peer_container, fill_random_part) -{ - rai::peer_container peers (rai::endpoint{}); - std::array target; - auto half (target.size () / 2); - for (auto i (0); i < half; ++i) - { - peers.insert (rai::endpoint (boost::asio::ip::address_v6::loopback (), i + 1), 0); - } - std::fill (target.begin (), target.end (), rai::endpoint (boost::asio::ip::address_v6::loopback (), 10000)); - peers.random_fill (target); - ASSERT_TRUE (std::none_of (target.begin (), target.begin () + half, [](rai::endpoint const & endpoint_a) { return endpoint_a == rai::endpoint (boost::asio::ip::address_v6::loopback (), 10000); })); - ASSERT_TRUE (std::none_of (target.begin (), target.begin () + half, [](rai::endpoint const & endpoint_a) { return endpoint_a == rai::endpoint (boost::asio::ip::address_v6::loopback (), 0); })); - ASSERT_TRUE (std::all_of (target.begin () + half, target.end (), [](rai::endpoint const & endpoint_a) { return endpoint_a == rai::endpoint (boost::asio::ip::address_v6::any (), 0); })); -} - -TEST (peer_container, list_fanout) -{ - rai::peer_container peers (rai::endpoint{}); - auto list1 (peers.list_fanout ()); - ASSERT_TRUE (list1.empty ()); - for (auto i (0); i < 1000; ++i) - { - ASSERT_FALSE (peers.insert (rai::endpoint (boost::asio::ip::address_v6::loopback (), 10000 + i), rai::protocol_version)); - } - auto list2 (peers.list_fanout ()); - ASSERT_EQ (32, list2.size ()); -} - -TEST (peer_container, rep_weight) -{ - rai::peer_container peers (rai::endpoint{}); - peers.insert (rai::endpoint (boost::asio::ip::address_v6::loopback (), 24001), 0); - ASSERT_TRUE (peers.representatives (1).empty ()); - rai::endpoint endpoint0 (boost::asio::ip::address_v6::loopback (), 24000); - rai::endpoint endpoint1 (boost::asio::ip::address_v6::loopback (), 24002); - rai::endpoint endpoint2 (boost::asio::ip::address_v6::loopback (), 24003); - rai::amount amount (100); - peers.insert (endpoint2, rai::protocol_version); - peers.insert (endpoint0, rai::protocol_version); - peers.insert (endpoint1, rai::protocol_version); - rai::keypair keypair; - peers.rep_response (endpoint0, keypair.pub, amount); - auto reps (peers.representatives (1)); - ASSERT_EQ (1, reps.size ()); - ASSERT_EQ (100, reps[0].rep_weight.number ()); - ASSERT_EQ (keypair.pub, reps[0].probable_rep_account); - ASSERT_EQ (endpoint0, reps[0].endpoint); -} - -// Test to make sure we don't repeatedly send keepalive messages to nodes that aren't responding -TEST (peer_container, reachout) -{ - rai::peer_container peers (rai::endpoint{}); - rai::endpoint endpoint0 (boost::asio::ip::address_v6::loopback (), 24000); - // Make sure having been contacted by them already indicates we shouldn't reach out - peers.insert (endpoint0, rai::protocol_version); - ASSERT_TRUE (peers.reachout (endpoint0)); - rai::endpoint endpoint1 (boost::asio::ip::address_v6::loopback (), 24001); - ASSERT_FALSE (peers.reachout (endpoint1)); - // Reaching out to them once should signal we shouldn't reach out again. - ASSERT_TRUE (peers.reachout (endpoint1)); - // Make sure we don't purge new items - peers.purge_list (std::chrono::steady_clock::now () - std::chrono::seconds (10)); - ASSERT_TRUE (peers.reachout (endpoint1)); - // Make sure we purge old items - peers.purge_list (std::chrono::steady_clock::now () + std::chrono::seconds (10)); - ASSERT_FALSE (peers.reachout (endpoint1)); -} - -TEST (peer_container, depeer) -{ - rai::peer_container peers (rai::endpoint{}); - rai::endpoint endpoint0 (boost::asio::ip::address_v6::loopback (), 24000); - peers.contacted (endpoint0, rai::protocol_version_min - 1); - ASSERT_EQ (0, peers.size ()); -} diff --git a/rai/lib/blocks.hpp b/rai/lib/blocks.hpp deleted file mode 100644 index e4dbb125..00000000 --- a/rai/lib/blocks.hpp +++ /dev/null @@ -1,336 +0,0 @@ -#pragma once - -#include - -#include -#include -#include -#include -#include - -namespace rai -{ -std::string to_string_hex (uint64_t); -bool from_string_hex (std::string const &, uint64_t &); -// We operate on streams of uint8_t by convention -using stream = std::basic_streambuf; -// Read a raw byte stream the size of `T' and fill value. -template -bool read (rai::stream & stream_a, T & value) -{ - static_assert (std::is_pod::value, "Can't stream read non-standard layout types"); - auto amount_read (stream_a.sgetn (reinterpret_cast (&value), sizeof (value))); - return amount_read != sizeof (value); -} -template -void write (rai::stream & stream_a, T const & value) -{ - static_assert (std::is_pod::value, "Can't stream write non-standard layout types"); - auto amount_written (stream_a.sputn (reinterpret_cast (&value), sizeof (value))); - assert (amount_written == sizeof (value)); -} -class block_visitor; -enum class block_type : uint8_t -{ - invalid = 0, - not_a_block = 1, - send = 2, - receive = 3, - open = 4, - change = 5, - state = 6 -}; -class block -{ -public: - // Return a digest of the hashables in this block. - rai::block_hash hash () const; - // Return a digest of hashables and non-hashables in this block. - rai::block_hash full_hash () const; - std::string to_json (); - virtual void hash (blake2b_state &) const = 0; - virtual uint64_t block_work () const = 0; - virtual void block_work_set (uint64_t) = 0; - // Previous block in account's chain, zero for open block - virtual rai::block_hash previous () const = 0; - // Source block for open/receive blocks, zero otherwise. - virtual rai::block_hash source () const = 0; - // Previous block or account number for open blocks - virtual rai::block_hash root () const = 0; - // Link field for state blocks, zero otherwise. - virtual rai::block_hash link () const = 0; - virtual rai::account representative () const = 0; - virtual void serialize (rai::stream &) const = 0; - virtual void serialize_json (std::string &) const = 0; - virtual void visit (rai::block_visitor &) const = 0; - virtual bool operator== (rai::block const &) const = 0; - virtual rai::block_type type () const = 0; - virtual rai::signature block_signature () const = 0; - virtual void signature_set (rai::uint512_union const &) = 0; - virtual ~block () = default; - virtual bool valid_predecessor (rai::block const &) const = 0; -}; -class send_hashables -{ -public: - send_hashables () = default; - send_hashables (rai::account const &, rai::block_hash const &, rai::amount const &); - send_hashables (bool &, rai::stream &); - send_hashables (bool &, boost::property_tree::ptree const &); - void hash (blake2b_state &) const; - rai::block_hash previous; - rai::account destination; - rai::amount balance; -}; -class send_block : public rai::block -{ -public: - send_block () = default; - send_block (rai::block_hash const &, rai::account const &, rai::amount const &, rai::raw_key const &, rai::public_key const &, uint64_t); - send_block (bool &, rai::stream &); - send_block (bool &, boost::property_tree::ptree const &); - virtual ~send_block () = default; - using rai::block::hash; - void hash (blake2b_state &) const override; - uint64_t block_work () const override; - void block_work_set (uint64_t) override; - rai::block_hash previous () const override; - rai::block_hash source () const override; - rai::block_hash root () const override; - rai::block_hash link () const override; - rai::account representative () const override; - void serialize (rai::stream &) const override; - void serialize_json (std::string &) const override; - bool deserialize (rai::stream &); - bool deserialize_json (boost::property_tree::ptree const &); - void visit (rai::block_visitor &) const override; - rai::block_type type () const override; - rai::signature block_signature () const override; - void signature_set (rai::uint512_union const &) override; - bool operator== (rai::block const &) const override; - bool operator== (rai::send_block const &) const; - bool valid_predecessor (rai::block const &) const override; - static size_t constexpr size = sizeof (rai::account) + sizeof (rai::block_hash) + sizeof (rai::amount) + sizeof (rai::signature) + sizeof (uint64_t); - send_hashables hashables; - rai::signature signature; - uint64_t work; -}; -class receive_hashables -{ -public: - receive_hashables () = default; - receive_hashables (rai::block_hash const &, rai::block_hash const &); - receive_hashables (bool &, rai::stream &); - receive_hashables (bool &, boost::property_tree::ptree const &); - void hash (blake2b_state &) const; - rai::block_hash previous; - rai::block_hash source; -}; -class receive_block : public rai::block -{ -public: - receive_block () = default; - receive_block (rai::block_hash const &, rai::block_hash const &, rai::raw_key const &, rai::public_key const &, uint64_t); - receive_block (bool &, rai::stream &); - receive_block (bool &, boost::property_tree::ptree const &); - virtual ~receive_block () = default; - using rai::block::hash; - void hash (blake2b_state &) const override; - uint64_t block_work () const override; - void block_work_set (uint64_t) override; - rai::block_hash previous () const override; - rai::block_hash source () const override; - rai::block_hash root () const override; - rai::block_hash link () const override; - rai::account representative () const override; - void serialize (rai::stream &) const override; - void serialize_json (std::string &) const override; - bool deserialize (rai::stream &); - bool deserialize_json (boost::property_tree::ptree const &); - void visit (rai::block_visitor &) const override; - rai::block_type type () const override; - rai::signature block_signature () const override; - void signature_set (rai::uint512_union const &) override; - bool operator== (rai::block const &) const override; - bool operator== (rai::receive_block const &) const; - bool valid_predecessor (rai::block const &) const override; - static size_t constexpr size = sizeof (rai::block_hash) + sizeof (rai::block_hash) + sizeof (rai::signature) + sizeof (uint64_t); - receive_hashables hashables; - rai::signature signature; - uint64_t work; -}; -class open_hashables -{ -public: - open_hashables () = default; - open_hashables (rai::block_hash const &, rai::account const &, rai::account const &); - open_hashables (bool &, rai::stream &); - open_hashables (bool &, boost::property_tree::ptree const &); - void hash (blake2b_state &) const; - rai::block_hash source; - rai::account representative; - rai::account account; -}; -class open_block : public rai::block -{ -public: - open_block () = default; - open_block (rai::block_hash const &, rai::account const &, rai::account const &, rai::raw_key const &, rai::public_key const &, uint64_t); - open_block (rai::block_hash const &, rai::account const &, rai::account const &, std::nullptr_t); - open_block (bool &, rai::stream &); - open_block (bool &, boost::property_tree::ptree const &); - virtual ~open_block () = default; - using rai::block::hash; - void hash (blake2b_state &) const override; - uint64_t block_work () const override; - void block_work_set (uint64_t) override; - rai::block_hash previous () const override; - rai::block_hash source () const override; - rai::block_hash root () const override; - rai::block_hash link () const override; - rai::account representative () const override; - void serialize (rai::stream &) const override; - void serialize_json (std::string &) const override; - bool deserialize (rai::stream &); - bool deserialize_json (boost::property_tree::ptree const &); - void visit (rai::block_visitor &) const override; - rai::block_type type () const override; - rai::signature block_signature () const override; - void signature_set (rai::uint512_union const &) override; - bool operator== (rai::block const &) const override; - bool operator== (rai::open_block const &) const; - bool valid_predecessor (rai::block const &) const override; - static size_t constexpr size = sizeof (rai::block_hash) + sizeof (rai::account) + sizeof (rai::account) + sizeof (rai::signature) + sizeof (uint64_t); - rai::open_hashables hashables; - rai::signature signature; - uint64_t work; -}; -class change_hashables -{ -public: - change_hashables () = default; - change_hashables (rai::block_hash const &, rai::account const &); - change_hashables (bool &, rai::stream &); - change_hashables (bool &, boost::property_tree::ptree const &); - void hash (blake2b_state &) const; - rai::block_hash previous; - rai::account representative; -}; -class change_block : public rai::block -{ -public: - change_block () = default; - change_block (rai::block_hash const &, rai::account const &, rai::raw_key const &, rai::public_key const &, uint64_t); - change_block (bool &, rai::stream &); - change_block (bool &, boost::property_tree::ptree const &); - virtual ~change_block () = default; - using rai::block::hash; - void hash (blake2b_state &) const override; - uint64_t block_work () const override; - void block_work_set (uint64_t) override; - rai::block_hash previous () const override; - rai::block_hash source () const override; - rai::block_hash root () const override; - rai::block_hash link () const override; - rai::account representative () const override; - void serialize (rai::stream &) const override; - void serialize_json (std::string &) const override; - bool deserialize (rai::stream &); - bool deserialize_json (boost::property_tree::ptree const &); - void visit (rai::block_visitor &) const override; - rai::block_type type () const override; - rai::signature block_signature () const override; - void signature_set (rai::uint512_union const &) override; - bool operator== (rai::block const &) const override; - bool operator== (rai::change_block const &) const; - bool valid_predecessor (rai::block const &) const override; - static size_t constexpr size = sizeof (rai::block_hash) + sizeof (rai::account) + sizeof (rai::signature) + sizeof (uint64_t); - rai::change_hashables hashables; - rai::signature signature; - uint64_t work; -}; -class state_hashables -{ -public: - state_hashables () = default; - state_hashables (rai::account const &, rai::block_hash const &, rai::account const &, rai::amount const &, rai::uint256_union const &); - state_hashables (bool &, rai::stream &); - state_hashables (bool &, boost::property_tree::ptree const &); - void hash (blake2b_state &) const; - // Account# / public key that operates this account - // Uses: - // Bulk signature validation in advance of further ledger processing - // Arranging uncomitted transactions by account - rai::account account; - // Previous transaction in this chain - rai::block_hash previous; - // Representative of this account - rai::account representative; - // Current balance of this account - // Allows lookup of account balance simply by looking at the head block - rai::amount balance; - // Link field contains source block_hash if receiving, destination account if sending - rai::uint256_union link; -}; -class state_block : public rai::block -{ -public: - state_block () = default; - state_block (rai::account const &, rai::block_hash const &, rai::account const &, rai::amount const &, rai::uint256_union const &, rai::raw_key const &, rai::public_key const &, uint64_t); - state_block (bool &, rai::stream &); - state_block (bool &, boost::property_tree::ptree const &); - virtual ~state_block () = default; - using rai::block::hash; - void hash (blake2b_state &) const override; - uint64_t block_work () const override; - void block_work_set (uint64_t) override; - rai::block_hash previous () const override; - rai::block_hash source () const override; - rai::block_hash root () const override; - rai::block_hash link () const override; - rai::account representative () const override; - void serialize (rai::stream &) const override; - void serialize_json (std::string &) const override; - bool deserialize (rai::stream &); - bool deserialize_json (boost::property_tree::ptree const &); - void visit (rai::block_visitor &) const override; - rai::block_type type () const override; - rai::signature block_signature () const override; - void signature_set (rai::uint512_union const &) override; - bool operator== (rai::block const &) const override; - bool operator== (rai::state_block const &) const; - bool valid_predecessor (rai::block const &) const override; - static size_t constexpr size = sizeof (rai::account) + sizeof (rai::block_hash) + sizeof (rai::account) + sizeof (rai::amount) + sizeof (rai::uint256_union) + sizeof (rai::signature) + sizeof (uint64_t); - rai::state_hashables hashables; - rai::signature signature; - uint64_t work; -}; -class block_visitor -{ -public: - virtual void send_block (rai::send_block const &) = 0; - virtual void receive_block (rai::receive_block const &) = 0; - virtual void open_block (rai::open_block const &) = 0; - virtual void change_block (rai::change_block const &) = 0; - virtual void state_block (rai::state_block const &) = 0; - virtual ~block_visitor () = default; -}; -/** - * This class serves to find and return unique variants of a block in order to minimize memory usage - */ -class block_uniquer -{ -public: - std::shared_ptr unique (std::shared_ptr); - size_t size (); - -private: - std::mutex mutex; - std::unordered_map> blocks; - static unsigned constexpr cleanup_count = 2; -}; -std::shared_ptr deserialize_block (rai::stream &, rai::block_uniquer * = nullptr); -std::shared_ptr deserialize_block (rai::stream &, rai::block_type, rai::block_uniquer * = nullptr); -std::shared_ptr deserialize_block_json (boost::property_tree::ptree const &, rai::block_uniquer * = nullptr); -void serialize_block (rai::stream &, rai::block const &); -} diff --git a/rai/lib/plat/darwin/thread_role.cpp b/rai/lib/plat/darwin/thread_role.cpp deleted file mode 100644 index 014b5040..00000000 --- a/rai/lib/plat/darwin/thread_role.cpp +++ /dev/null @@ -1,7 +0,0 @@ -#include -#include - -void rai::thread_role::set_name (std::string thread_name) -{ - pthread_setname_np (thread_name.c_str ()); -} diff --git a/rai/lib/plat/default/priority.cpp b/rai/lib/plat/default/priority.cpp deleted file mode 100644 index 5ab8df31..00000000 --- a/rai/lib/plat/default/priority.cpp +++ /dev/null @@ -1,5 +0,0 @@ -#include - -void rai::work_thread_reprioritize () -{ -} diff --git a/rai/lib/plat/linux/thread_role.cpp b/rai/lib/plat/linux/thread_role.cpp deleted file mode 100644 index d4c038ed..00000000 --- a/rai/lib/plat/linux/thread_role.cpp +++ /dev/null @@ -1,7 +0,0 @@ -#include -#include - -void rai::thread_role::set_name (std::string thread_name) -{ - pthread_setname_np (pthread_self (), thread_name.c_str ()); -} diff --git a/rai/lib/work.hpp b/rai/lib/work.hpp deleted file mode 100644 index c81e4d8d..00000000 --- a/rai/lib/work.hpp +++ /dev/null @@ -1,51 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include - -#include -#include -#include -#include - -namespace rai -{ -class block; -bool work_validate (rai::block_hash const &, uint64_t, uint64_t * = nullptr); -bool work_validate (rai::block const &, uint64_t * = nullptr); -uint64_t work_value (rai::block_hash const &, uint64_t); -class opencl_work; -class work_item -{ -public: - rai::uint256_union item; - std::function const &)> callback; - uint64_t difficulty; -}; -class work_pool -{ -public: - work_pool (unsigned, std::function (rai::uint256_union const &)> = nullptr); - ~work_pool (); - void loop (uint64_t); - void stop (); - void cancel (rai::uint256_union const &); - void generate (rai::uint256_union const &, std::function const &)>, uint64_t = rai::work_pool::publish_threshold); - uint64_t generate (rai::uint256_union const &, uint64_t = rai::work_pool::publish_threshold); - std::atomic ticket; - bool done; - std::vector threads; - std::list pending; - std::mutex mutex; - std::condition_variable producer_condition; - std::function (rai::uint256_union const &)> opencl; - rai::observer_set work_observers; - // Local work threshold for rate-limiting publishing blocks. ~5 seconds of work. - static uint64_t const publish_test_threshold = 0xff00000000000000; - static uint64_t const publish_full_threshold = 0xffffffc000000000; - static uint64_t const publish_threshold = rai::rai_network == rai::rai_networks::rai_test_network ? publish_test_threshold : publish_full_threshold; -}; -} diff --git a/rai/node/bootstrap.hpp b/rai/node/bootstrap.hpp deleted file mode 100644 index caedec93..00000000 --- a/rai/node/bootstrap.hpp +++ /dev/null @@ -1,341 +0,0 @@ -#pragma once - -#include -#include -#include - -#include -#include -#include -#include -#include - -#include -#include - -namespace rai -{ -class bootstrap_attempt; -class bootstrap_client; -class node; -enum class sync_result -{ - success, - error, - fork -}; -class socket : public std::enable_shared_from_this -{ -public: - socket (std::shared_ptr); - void async_connect (rai::tcp_endpoint const &, std::function); - void async_read (std::shared_ptr>, size_t, std::function); - void async_write (std::shared_ptr>, std::function); - void start (std::chrono::steady_clock::time_point = std::chrono::steady_clock::now () + std::chrono::seconds (5)); - void stop (); - void close (); - void checkup (); - rai::tcp_endpoint remote_endpoint (); - boost::asio::ip::tcp::socket socket_m; - -private: - std::atomic cutoff; - std::shared_ptr node; -}; - -/** - * The length of every message header, parsed by rai::message::read_header () - * The 2 here represents the size of a std::bitset<16>, which is 2 chars long normally - */ -static const int bootstrap_message_header_size = sizeof (rai::message_header::magic_number) + sizeof (uint8_t) + sizeof (uint8_t) + sizeof (uint8_t) + sizeof (rai::message_type) + 2; - -class bootstrap_client; -class pull_info -{ -public: - typedef rai::bulk_pull::count_t count_t; - pull_info (); - pull_info (rai::account const &, rai::block_hash const &, rai::block_hash const &, count_t = 0); - rai::account account; - rai::block_hash head; - rai::block_hash end; - count_t count; - unsigned attempts; -}; -class frontier_req_client; -class bulk_push_client; -class bootstrap_attempt : public std::enable_shared_from_this -{ -public: - bootstrap_attempt (std::shared_ptr node_a); - ~bootstrap_attempt (); - void run (); - std::shared_ptr connection (std::unique_lock &); - bool consume_future (std::future &); - void populate_connections (); - bool request_frontier (std::unique_lock &); - void request_pull (std::unique_lock &); - void request_push (std::unique_lock &); - void add_connection (rai::endpoint const &); - void pool_connection (std::shared_ptr); - void stop (); - void requeue_pull (rai::pull_info const &); - void add_pull (rai::pull_info const &); - bool still_pulling (); - unsigned target_connections (size_t pulls_remaining); - bool should_log (); - void add_bulk_push_target (rai::block_hash const &, rai::block_hash const &); - bool process_block (std::shared_ptr, uint64_t, bool); - void lazy_run (); - void lazy_start (rai::block_hash const &); - void lazy_add (rai::block_hash const &); - bool lazy_finished (); - void lazy_pull_flush (); - std::chrono::steady_clock::time_point next_log; - std::deque> clients; - std::weak_ptr connection_frontier_request; - std::weak_ptr frontiers; - std::weak_ptr push; - std::deque pulls; - std::deque> idle; - std::atomic connections; - std::atomic pulling; - std::shared_ptr node; - std::atomic account_count; - std::atomic total_blocks; - std::vector> bulk_push_targets; - bool stopped; - bool lazy_mode; - std::mutex mutex; - std::condition_variable condition; - // Lazy bootstrap - std::unordered_set lazy_blocks; - std::unordered_map> lazy_state_unknown; - std::unordered_map lazy_balances; - std::unordered_set lazy_keys; - std::deque lazy_pulls; - std::atomic lazy_stopped; - uint64_t lazy_max_pull_blocks = (rai::rai_network == rai::rai_networks::rai_test_network) ? 2 : 512; - uint64_t lazy_max_stopped = 256; - std::mutex lazy_mutex; -}; -class frontier_req_client : public std::enable_shared_from_this -{ -public: - frontier_req_client (std::shared_ptr); - ~frontier_req_client (); - void run (); - void receive_frontier (); - void received_frontier (boost::system::error_code const &, size_t); - void request_account (rai::account const &, rai::block_hash const &); - void unsynced (rai::block_hash const &, rai::block_hash const &); - void next (rai::transaction const &); - void insert_pull (rai::pull_info const &); - std::shared_ptr connection; - rai::account current; - rai::block_hash frontier; - unsigned count; - rai::account landing; - rai::account faucet; - std::chrono::steady_clock::time_point start_time; - std::promise promise; - /** A very rough estimate of the cost of `bulk_push`ing missing blocks */ - uint64_t bulk_push_cost; - std::deque> accounts; -}; -class bulk_pull_client : public std::enable_shared_from_this -{ -public: - bulk_pull_client (std::shared_ptr, rai::pull_info const &); - ~bulk_pull_client (); - void request (); - void receive_block (); - void received_type (); - void received_block (boost::system::error_code const &, size_t, rai::block_type); - rai::block_hash first (); - std::shared_ptr connection; - rai::block_hash expected; - rai::pull_info pull; - uint64_t total_blocks; -}; -class bootstrap_client : public std::enable_shared_from_this -{ -public: - bootstrap_client (std::shared_ptr, std::shared_ptr, rai::tcp_endpoint const &); - ~bootstrap_client (); - void run (); - std::shared_ptr shared (); - void stop (bool force); - double block_rate () const; - double elapsed_seconds () const; - std::shared_ptr node; - std::shared_ptr attempt; - std::shared_ptr socket; - std::shared_ptr> receive_buffer; - rai::tcp_endpoint endpoint; - std::chrono::steady_clock::time_point start_time; - std::atomic block_count; - std::atomic pending_stop; - std::atomic hard_stop; -}; -class bulk_push_client : public std::enable_shared_from_this -{ -public: - bulk_push_client (std::shared_ptr const &); - ~bulk_push_client (); - void start (); - void push (rai::transaction const &); - void push_block (rai::block const &); - void send_finished (); - std::shared_ptr connection; - std::promise promise; - std::pair current_target; -}; -class bootstrap_initiator -{ -public: - bootstrap_initiator (rai::node &); - ~bootstrap_initiator (); - void bootstrap (rai::endpoint const &, bool add_to_peers = true); - void bootstrap (); - void bootstrap_lazy (rai::block_hash const &, bool = false); - void run_bootstrap (); - void notify_listeners (bool); - void add_observer (std::function const &); - bool in_progress (); - std::shared_ptr current_attempt (); - void stop (); - -private: - rai::node & node; - std::shared_ptr attempt; - bool stopped; - std::mutex mutex; - std::condition_variable condition; - std::vector> observers; - boost::thread thread; -}; -class bootstrap_server; -class bootstrap_listener -{ -public: - bootstrap_listener (boost::asio::io_context &, uint16_t, rai::node &); - void start (); - void stop (); - void accept_connection (); - void accept_action (boost::system::error_code const &, std::shared_ptr); - std::mutex mutex; - std::unordered_map> connections; - rai::tcp_endpoint endpoint (); - boost::asio::ip::tcp::acceptor acceptor; - rai::tcp_endpoint local; - boost::asio::io_context & io_ctx; - rai::node & node; - bool on; -}; -class message; -class bootstrap_server : public std::enable_shared_from_this -{ -public: - bootstrap_server (std::shared_ptr, std::shared_ptr); - ~bootstrap_server (); - void receive (); - void receive_header_action (boost::system::error_code const &, size_t); - void receive_bulk_pull_action (boost::system::error_code const &, size_t, rai::message_header const &); - void receive_bulk_pull_account_action (boost::system::error_code const &, size_t, rai::message_header const &); - void receive_bulk_pull_blocks_action (boost::system::error_code const &, size_t, rai::message_header const &); - void receive_frontier_req_action (boost::system::error_code const &, size_t, rai::message_header const &); - void receive_bulk_push_action (); - void add_request (std::unique_ptr); - void finish_request (); - void run_next (); - std::shared_ptr> receive_buffer; - std::shared_ptr socket; - std::shared_ptr node; - std::mutex mutex; - std::queue> requests; -}; -class bulk_pull; -class bulk_pull_server : public std::enable_shared_from_this -{ -public: - bulk_pull_server (std::shared_ptr const &, std::unique_ptr); - void set_current_end (); - std::shared_ptr get_next (); - void send_next (); - void sent_action (boost::system::error_code const &, size_t); - void send_finished (); - void no_block_sent (boost::system::error_code const &, size_t); - std::shared_ptr connection; - std::unique_ptr request; - std::shared_ptr> send_buffer; - rai::block_hash current; - bool include_start; - rai::bulk_pull::count_t max_count; - rai::bulk_pull::count_t sent_count; -}; -class bulk_pull_account; -class bulk_pull_account_server : public std::enable_shared_from_this -{ -public: - bulk_pull_account_server (std::shared_ptr const &, std::unique_ptr); - void set_params (); - std::pair, std::unique_ptr> get_next (); - void send_frontier (); - void send_next_block (); - void sent_action (boost::system::error_code const &, size_t); - void send_finished (); - void complete (boost::system::error_code const &, size_t); - std::shared_ptr connection; - std::unique_ptr request; - std::shared_ptr> send_buffer; - std::unordered_map deduplication; - rai::pending_key current_key; - bool pending_address_only; - bool pending_include_address; - bool invalid_request; -}; -class bulk_pull_blocks; -class bulk_pull_blocks_server : public std::enable_shared_from_this -{ -public: - bulk_pull_blocks_server (std::shared_ptr const &, std::unique_ptr); - void set_params (); - std::shared_ptr get_next (); - void send_next (); - void send_finished (); - void no_block_sent (boost::system::error_code const &, size_t); - std::shared_ptr connection; - std::unique_ptr request; - std::shared_ptr> send_buffer; -}; -class bulk_push_server : public std::enable_shared_from_this -{ -public: - bulk_push_server (std::shared_ptr const &); - void receive (); - void receive_block (); - void received_type (); - void received_block (boost::system::error_code const &, size_t, rai::block_type); - std::shared_ptr> receive_buffer; - std::shared_ptr connection; -}; -class frontier_req; -class frontier_req_server : public std::enable_shared_from_this -{ -public: - frontier_req_server (std::shared_ptr const &, std::unique_ptr); - void send_next (); - void sent_action (boost::system::error_code const &, size_t); - void send_finished (); - void no_block_sent (boost::system::error_code const &, size_t); - void next (); - std::shared_ptr connection; - rai::account current; - rai::block_hash frontier; - std::unique_ptr request; - std::shared_ptr> send_buffer; - size_t count; - std::deque> accounts; -}; -} diff --git a/rai/node/common.cpp b/rai/node/common.cpp deleted file mode 100644 index ac6cd27e..00000000 --- a/rai/node/common.cpp +++ /dev/null @@ -1,974 +0,0 @@ - -#include - -#include -#include - -#include - -std::array constexpr rai::message_header::magic_number; -std::bitset<16> constexpr rai::message_header::block_type_mask; - -rai::message_header::message_header (rai::message_type type_a) : -version_max (rai::protocol_version), -version_using (rai::protocol_version), -version_min (rai::protocol_version_min), -type (type_a) -{ -} - -rai::message_header::message_header (bool & error_a, rai::stream & stream_a) -{ - if (!error_a) - { - error_a = deserialize (stream_a); - } -} - -void rai::message_header::serialize (rai::stream & stream_a) const -{ - rai::write (stream_a, rai::message_header::magic_number); - rai::write (stream_a, version_max); - rai::write (stream_a, version_using); - rai::write (stream_a, version_min); - rai::write (stream_a, type); - rai::write (stream_a, static_cast (extensions.to_ullong ())); -} - -bool rai::message_header::deserialize (rai::stream & stream_a) -{ - uint16_t extensions_l; - std::array magic_number_l; - auto result (rai::read (stream_a, magic_number_l)); - result = result || magic_number_l != magic_number; - result = result || rai::read (stream_a, version_max); - result = result || rai::read (stream_a, version_using); - result = result || rai::read (stream_a, version_min); - result = result || rai::read (stream_a, type); - result = result || rai::read (stream_a, extensions_l); - if (!result) - { - extensions = extensions_l; - } - return result; -} - -rai::message::message (rai::message_type type_a) : -header (type_a) -{ -} - -rai::message::message (rai::message_header const & header_a) : -header (header_a) -{ -} - -rai::block_type rai::message_header::block_type () const -{ - return static_cast (((extensions & block_type_mask) >> 8).to_ullong ()); -} - -void rai::message_header::block_type_set (rai::block_type type_a) -{ - extensions &= ~block_type_mask; - extensions |= std::bitset<16> (static_cast (type_a) << 8); -} - -bool rai::message_header::bulk_pull_is_count_present () const -{ - auto result (false); - if (type == rai::message_type::bulk_pull) - { - if (extensions.test (bulk_pull_count_present_flag)) - { - result = true; - } - } - - return result; -} - -// MTU - IP header - UDP header -const size_t rai::message_parser::max_safe_udp_message_size = 508; - -std::string rai::message_parser::status_string () -{ - switch (status) - { - case rai::message_parser::parse_status::success: - { - return "success"; - } - case rai::message_parser::parse_status::insufficient_work: - { - return "insufficient_work"; - } - case rai::message_parser::parse_status::invalid_header: - { - return "invalid_header"; - } - case rai::message_parser::parse_status::invalid_message_type: - { - return "invalid_message_type"; - } - case rai::message_parser::parse_status::invalid_keepalive_message: - { - return "invalid_keepalive_message"; - } - case rai::message_parser::parse_status::invalid_publish_message: - { - return "invalid_publish_message"; - } - case rai::message_parser::parse_status::invalid_confirm_req_message: - { - return "invalid_confirm_req_message"; - } - case rai::message_parser::parse_status::invalid_confirm_ack_message: - { - return "invalid_confirm_ack_message"; - } - case rai::message_parser::parse_status::invalid_node_id_handshake_message: - { - return "invalid_node_id_handshake_message"; - } - case rai::message_parser::parse_status::outdated_version: - { - return "outdated_version"; - } - case rai::message_parser::parse_status::invalid_magic: - { - return "invalid_magic"; - } - case rai::message_parser::parse_status::invalid_network: - { - return "invalid_network"; - } - } - - assert (false); - - return "[unknown parse_status]"; -} - -rai::message_parser::message_parser (rai::block_uniquer & block_uniquer_a, rai::vote_uniquer & vote_uniquer_a, rai::message_visitor & visitor_a, rai::work_pool & pool_a) : -block_uniquer (block_uniquer_a), -vote_uniquer (vote_uniquer_a), -visitor (visitor_a), -pool (pool_a), -status (parse_status::success) -{ -} - -void rai::message_parser::deserialize_buffer (uint8_t const * buffer_a, size_t size_a) -{ - status = parse_status::success; - auto error (false); - if (size_a <= max_safe_udp_message_size) - { - // Guaranteed to be deliverable - rai::bufferstream stream (buffer_a, size_a); - rai::message_header header (error, stream); - if (!error) - { - if (rai::rai_network == rai::rai_networks::rai_beta_network && header.version_using < rai::protocol_version_reasonable_min) - { - status = parse_status::outdated_version; - } - else if (!header.valid_magic ()) - { - status = parse_status::invalid_magic; - } - else if (!header.valid_network ()) - { - status = parse_status::invalid_network; - } - else - { - switch (header.type) - { - case rai::message_type::keepalive: - { - deserialize_keepalive (stream, header); - break; - } - case rai::message_type::publish: - { - deserialize_publish (stream, header); - break; - } - case rai::message_type::confirm_req: - { - deserialize_confirm_req (stream, header); - break; - } - case rai::message_type::confirm_ack: - { - deserialize_confirm_ack (stream, header); - break; - } - case rai::message_type::node_id_handshake: - { - deserialize_node_id_handshake (stream, header); - break; - } - default: - { - status = parse_status::invalid_message_type; - break; - } - } - } - } - else - { - status = parse_status::invalid_header; - } - } -} - -void rai::message_parser::deserialize_keepalive (rai::stream & stream_a, rai::message_header const & header_a) -{ - auto error (false); - rai::keepalive incoming (error, stream_a, header_a); - if (!error && at_end (stream_a)) - { - visitor.keepalive (incoming); - } - else - { - status = parse_status::invalid_keepalive_message; - } -} - -void rai::message_parser::deserialize_publish (rai::stream & stream_a, rai::message_header const & header_a) -{ - auto error (false); - rai::publish incoming (error, stream_a, header_a, &block_uniquer); - if (!error && at_end (stream_a)) - { - if (!rai::work_validate (*incoming.block)) - { - visitor.publish (incoming); - } - else - { - status = parse_status::insufficient_work; - } - } - else - { - status = parse_status::invalid_publish_message; - } -} - -void rai::message_parser::deserialize_confirm_req (rai::stream & stream_a, rai::message_header const & header_a) -{ - auto error (false); - rai::confirm_req incoming (error, stream_a, header_a, &block_uniquer); - if (!error && at_end (stream_a)) - { - if (!rai::work_validate (*incoming.block)) - { - visitor.confirm_req (incoming); - } - else - { - status = parse_status::insufficient_work; - } - } - else - { - status = parse_status::invalid_confirm_req_message; - } -} - -void rai::message_parser::deserialize_confirm_ack (rai::stream & stream_a, rai::message_header const & header_a) -{ - auto error (false); - rai::confirm_ack incoming (error, stream_a, header_a, &vote_uniquer); - if (!error && at_end (stream_a)) - { - for (auto & vote_block : incoming.vote->blocks) - { - if (!vote_block.which ()) - { - auto block (boost::get> (vote_block)); - if (rai::work_validate (*block)) - { - status = parse_status::insufficient_work; - break; - } - } - } - if (status == parse_status::success) - { - visitor.confirm_ack (incoming); - } - } - else - { - status = parse_status::invalid_confirm_ack_message; - } -} - -void rai::message_parser::deserialize_node_id_handshake (rai::stream & stream_a, rai::message_header const & header_a) -{ - bool error_l (false); - rai::node_id_handshake incoming (error_l, stream_a, header_a); - if (!error_l && at_end (stream_a)) - { - visitor.node_id_handshake (incoming); - } - else - { - status = parse_status::invalid_node_id_handshake_message; - } -} - -bool rai::message_parser::at_end (rai::stream & stream_a) -{ - uint8_t junk; - auto end (rai::read (stream_a, junk)); - return end; -} - -rai::keepalive::keepalive () : -message (rai::message_type::keepalive) -{ - rai::endpoint endpoint (boost::asio::ip::address_v6{}, 0); - for (auto i (peers.begin ()), n (peers.end ()); i != n; ++i) - { - *i = endpoint; - } -} - -rai::keepalive::keepalive (bool & error_a, rai::stream & stream_a, rai::message_header const & header_a) : -message (header_a) -{ - if (!error_a) - { - error_a = deserialize (stream_a); - } -} - -void rai::keepalive::visit (rai::message_visitor & visitor_a) const -{ - visitor_a.keepalive (*this); -} - -void rai::keepalive::serialize (rai::stream & stream_a) const -{ - header.serialize (stream_a); - for (auto i (peers.begin ()), j (peers.end ()); i != j; ++i) - { - assert (i->address ().is_v6 ()); - auto bytes (i->address ().to_v6 ().to_bytes ()); - write (stream_a, bytes); - write (stream_a, i->port ()); - } -} - -bool rai::keepalive::deserialize (rai::stream & stream_a) -{ - assert (header.type == rai::message_type::keepalive); - auto error (false); - for (auto i (peers.begin ()), j (peers.end ()); i != j && !error; ++i) - { - std::array address; - uint16_t port; - if (!read (stream_a, address) && !read (stream_a, port)) - { - *i = rai::endpoint (boost::asio::ip::address_v6 (address), port); - } - else - { - error = true; - } - } - return error; -} - -bool rai::keepalive::operator== (rai::keepalive const & other_a) const -{ - return peers == other_a.peers; -} - -rai::publish::publish (bool & error_a, rai::stream & stream_a, rai::message_header const & header_a, rai::block_uniquer * uniquer_a) : -message (header_a) -{ - if (!error_a) - { - error_a = deserialize (stream_a, uniquer_a); - } -} - -rai::publish::publish (std::shared_ptr block_a) : -message (rai::message_type::publish), -block (block_a) -{ - header.block_type_set (block->type ()); -} - -bool rai::publish::deserialize (rai::stream & stream_a, rai::block_uniquer * uniquer_a) -{ - assert (header.type == rai::message_type::publish); - block = rai::deserialize_block (stream_a, header.block_type (), uniquer_a); - auto result (block == nullptr); - return result; -} - -void rai::publish::serialize (rai::stream & stream_a) const -{ - assert (block != nullptr); - header.serialize (stream_a); - block->serialize (stream_a); -} - -void rai::publish::visit (rai::message_visitor & visitor_a) const -{ - visitor_a.publish (*this); -} - -bool rai::publish::operator== (rai::publish const & other_a) const -{ - return *block == *other_a.block; -} - -rai::confirm_req::confirm_req (bool & error_a, rai::stream & stream_a, rai::message_header const & header_a, rai::block_uniquer * uniquer_a) : -message (header_a) -{ - if (!error_a) - { - error_a = deserialize (stream_a, uniquer_a); - } -} - -rai::confirm_req::confirm_req (std::shared_ptr block_a) : -message (rai::message_type::confirm_req), -block (block_a) -{ - header.block_type_set (block->type ()); -} - -bool rai::confirm_req::deserialize (rai::stream & stream_a, rai::block_uniquer * uniquer_a) -{ - assert (header.type == rai::message_type::confirm_req); - block = rai::deserialize_block (stream_a, header.block_type (), uniquer_a); - auto result (block == nullptr); - return result; -} - -void rai::confirm_req::visit (rai::message_visitor & visitor_a) const -{ - visitor_a.confirm_req (*this); -} - -void rai::confirm_req::serialize (rai::stream & stream_a) const -{ - assert (block != nullptr); - header.serialize (stream_a); - block->serialize (stream_a); -} - -bool rai::confirm_req::operator== (rai::confirm_req const & other_a) const -{ - return *block == *other_a.block; -} - -rai::confirm_ack::confirm_ack (bool & error_a, rai::stream & stream_a, rai::message_header const & header_a, rai::vote_uniquer * uniquer_a) : -message (header_a), -vote (std::make_shared (error_a, stream_a, header.block_type ())) -{ - if (uniquer_a) - { - vote = uniquer_a->unique (vote); - } -} - -rai::confirm_ack::confirm_ack (std::shared_ptr vote_a) : -message (rai::message_type::confirm_ack), -vote (vote_a) -{ - auto & first_vote_block (vote_a->blocks[0]); - if (first_vote_block.which ()) - { - header.block_type_set (rai::block_type::not_a_block); - } - else - { - header.block_type_set (boost::get> (first_vote_block)->type ()); - } -} - -bool rai::confirm_ack::deserialize (rai::stream & stream_a, rai::vote_uniquer * uniquer_a) -{ - assert (header.type == rai::message_type::confirm_ack); - auto result (vote->deserialize (stream_a)); - if (uniquer_a) - { - vote = uniquer_a->unique (vote); - } - return result; -} - -void rai::confirm_ack::serialize (rai::stream & stream_a) const -{ - assert (header.block_type () == rai::block_type::not_a_block || header.block_type () == rai::block_type::send || header.block_type () == rai::block_type::receive || header.block_type () == rai::block_type::open || header.block_type () == rai::block_type::change || header.block_type () == rai::block_type::state); - header.serialize (stream_a); - vote->serialize (stream_a, header.block_type ()); -} - -bool rai::confirm_ack::operator== (rai::confirm_ack const & other_a) const -{ - auto result (*vote == *other_a.vote); - return result; -} - -void rai::confirm_ack::visit (rai::message_visitor & visitor_a) const -{ - visitor_a.confirm_ack (*this); -} - -rai::frontier_req::frontier_req () : -message (rai::message_type::frontier_req) -{ -} - -rai::frontier_req::frontier_req (bool & error_a, rai::stream & stream_a, rai::message_header const & header_a) : -message (header_a) -{ - if (!error_a) - { - error_a = deserialize (stream_a); - } -} - -bool rai::frontier_req::deserialize (rai::stream & stream_a) -{ - assert (header.type == rai::message_type::frontier_req); - auto result (read (stream_a, start.bytes)); - if (!result) - { - result = read (stream_a, age); - if (!result) - { - result = read (stream_a, count); - } - } - return result; -} - -void rai::frontier_req::serialize (rai::stream & stream_a) const -{ - header.serialize (stream_a); - write (stream_a, start.bytes); - write (stream_a, age); - write (stream_a, count); -} - -void rai::frontier_req::visit (rai::message_visitor & visitor_a) const -{ - visitor_a.frontier_req (*this); -} - -bool rai::frontier_req::operator== (rai::frontier_req const & other_a) const -{ - return start == other_a.start && age == other_a.age && count == other_a.count; -} - -rai::bulk_pull::bulk_pull () : -message (rai::message_type::bulk_pull), -count (0) -{ -} - -rai::bulk_pull::bulk_pull (bool & error_a, rai::stream & stream_a, rai::message_header const & header_a) : -message (header_a), -count (0) -{ - if (!error_a) - { - error_a = deserialize (stream_a); - } -} - -void rai::bulk_pull::visit (rai::message_visitor & visitor_a) const -{ - visitor_a.bulk_pull (*this); -} - -bool rai::bulk_pull::deserialize (rai::stream & stream_a) -{ - assert (header.type == rai::message_type::bulk_pull); - auto result (read (stream_a, start)); - if (!result) - { - result = read (stream_a, end); - - if (!result) - { - if (is_count_present ()) - { - std::array count_buffer; - static_assert (sizeof (count) < (count_buffer.size () - 1), "count must fit within buffer"); - - result = read (stream_a, count_buffer); - if (count_buffer[0] != 0) - { - result = true; - } - else - { - memcpy (&count, count_buffer.data () + 1, sizeof (count)); - boost::endian::little_to_native_inplace (count); - } - } - else - { - count = 0; - } - } - } - return result; -} - -void rai::bulk_pull::serialize (rai::stream & stream_a) const -{ - /* - * Ensure the "count_present" flag is set if there - * is a limit specifed. Additionally, do not allow - * the "count_present" flag with a value of 0, since - * that is a sentinel which we use to mean "all blocks" - * and that is the behavior of not having the flag set - * so it is wasteful to do this. - */ - assert ((count == 0 && !is_count_present ()) || (count != 0 && is_count_present ())); - - header.serialize (stream_a); - write (stream_a, start); - write (stream_a, end); - - if (is_count_present ()) - { - std::array count_buffer{ { 0 } }; - decltype (count) count_little_endian; - static_assert (sizeof (count_little_endian) < (count_buffer.size () - 1), "count must fit within buffer"); - - count_little_endian = boost::endian::native_to_little (count); - memcpy (count_buffer.data () + 1, &count_little_endian, sizeof (count_little_endian)); - - write (stream_a, count_buffer); - } -} - -bool rai::bulk_pull::is_count_present () const -{ - return header.extensions.test (count_present_flag); -} - -void rai::bulk_pull::set_count_present (bool value_a) -{ - header.extensions.set (count_present_flag, value_a); -} - -rai::bulk_pull_account::bulk_pull_account () : -message (rai::message_type::bulk_pull_account) -{ -} - -rai::bulk_pull_account::bulk_pull_account (bool & error_a, rai::stream & stream_a, rai::message_header const & header_a) : -message (header_a) -{ - if (!error_a) - { - error_a = deserialize (stream_a); - } -} - -void rai::bulk_pull_account::visit (rai::message_visitor & visitor_a) const -{ - visitor_a.bulk_pull_account (*this); -} - -bool rai::bulk_pull_account::deserialize (rai::stream & stream_a) -{ - assert (header.type == rai::message_type::bulk_pull_account); - auto result (read (stream_a, account)); - if (!result) - { - result = read (stream_a, minimum_amount); - if (!result) - { - result = read (stream_a, flags); - } - } - return result; -} - -void rai::bulk_pull_account::serialize (rai::stream & stream_a) const -{ - header.serialize (stream_a); - write (stream_a, account); - write (stream_a, minimum_amount); - write (stream_a, flags); -} - -rai::bulk_pull_blocks::bulk_pull_blocks () : -message (rai::message_type::bulk_pull_blocks) -{ -} - -rai::bulk_pull_blocks::bulk_pull_blocks (bool & error_a, rai::stream & stream_a, rai::message_header const & header_a) : -message (header_a) -{ - if (!error_a) - { - error_a = deserialize (stream_a); - } -} - -void rai::bulk_pull_blocks::visit (rai::message_visitor & visitor_a) const -{ - visitor_a.bulk_pull_blocks (*this); -} - -bool rai::bulk_pull_blocks::deserialize (rai::stream & stream_a) -{ - assert (header.type == rai::message_type::bulk_pull_blocks); - auto result (read (stream_a, min_hash)); - if (!result) - { - result = read (stream_a, max_hash); - if (!result) - { - result = read (stream_a, mode); - if (!result) - { - result = read (stream_a, max_count); - } - } - } - return result; -} - -void rai::bulk_pull_blocks::serialize (rai::stream & stream_a) const -{ - header.serialize (stream_a); - write (stream_a, min_hash); - write (stream_a, max_hash); - write (stream_a, mode); - write (stream_a, max_count); -} - -rai::bulk_push::bulk_push () : -message (rai::message_type::bulk_push) -{ -} - -rai::bulk_push::bulk_push (rai::message_header const & header_a) : -message (header_a) -{ -} - -bool rai::bulk_push::deserialize (rai::stream & stream_a) -{ - assert (header.type == rai::message_type::bulk_push); - return false; -} - -void rai::bulk_push::serialize (rai::stream & stream_a) const -{ - header.serialize (stream_a); -} - -void rai::bulk_push::visit (rai::message_visitor & visitor_a) const -{ - visitor_a.bulk_push (*this); -} - -size_t constexpr rai::node_id_handshake::query_flag; -size_t constexpr rai::node_id_handshake::response_flag; - -rai::node_id_handshake::node_id_handshake (bool & error_a, rai::stream & stream_a, rai::message_header const & header_a) : -message (header_a), -query (boost::none), -response (boost::none) -{ - error_a = deserialize (stream_a); -} - -rai::node_id_handshake::node_id_handshake (boost::optional query, boost::optional> response) : -message (rai::message_type::node_id_handshake), -query (query), -response (response) -{ - if (query) - { - set_query_flag (true); - } - if (response) - { - set_response_flag (true); - } -} - -bool rai::node_id_handshake::deserialize (rai::stream & stream_a) -{ - auto result (false); - assert (header.type == rai::message_type::node_id_handshake); - if (!result && is_query_flag ()) - { - rai::uint256_union query_hash; - result = read (stream_a, query_hash); - if (!result) - { - query = query_hash; - } - } - if (!result && is_response_flag ()) - { - rai::account response_account; - result = read (stream_a, response_account); - if (!result) - { - rai::signature response_signature; - result = read (stream_a, response_signature); - if (!result) - { - response = std::make_pair (response_account, response_signature); - } - } - } - return result; -} - -void rai::node_id_handshake::serialize (rai::stream & stream_a) const -{ - header.serialize (stream_a); - if (query) - { - write (stream_a, *query); - } - if (response) - { - write (stream_a, response->first); - write (stream_a, response->second); - } -} - -bool rai::node_id_handshake::operator== (rai::node_id_handshake const & other_a) const -{ - auto result (*query == *other_a.query && *response == *other_a.response); - return result; -} - -bool rai::node_id_handshake::is_query_flag () const -{ - return header.extensions.test (query_flag); -} - -void rai::node_id_handshake::set_query_flag (bool value_a) -{ - header.extensions.set (query_flag, value_a); -} - -bool rai::node_id_handshake::is_response_flag () const -{ - return header.extensions.test (response_flag); -} - -void rai::node_id_handshake::set_response_flag (bool value_a) -{ - header.extensions.set (response_flag, value_a); -} - -void rai::node_id_handshake::visit (rai::message_visitor & visitor_a) const -{ - visitor_a.node_id_handshake (*this); -} - -rai::message_visitor::~message_visitor () -{ -} - -bool rai::parse_port (std::string const & string_a, uint16_t & port_a) -{ - bool result; - size_t converted; - try - { - port_a = std::stoul (string_a, &converted); - result = converted != string_a.size () || converted > std::numeric_limits::max (); - } - catch (...) - { - result = true; - } - return result; -} - -bool rai::parse_address_port (std::string const & string, boost::asio::ip::address & address_a, uint16_t & port_a) -{ - auto result (false); - auto port_position (string.rfind (':')); - if (port_position != std::string::npos && port_position > 0) - { - std::string port_string (string.substr (port_position + 1)); - try - { - uint16_t port; - result = parse_port (port_string, port); - if (!result) - { - boost::system::error_code ec; - auto address (boost::asio::ip::address_v6::from_string (string.substr (0, port_position), ec)); - if (!ec) - { - address_a = address; - port_a = port; - } - else - { - result = true; - } - } - else - { - result = true; - } - } - catch (...) - { - result = true; - } - } - else - { - result = true; - } - return result; -} - -bool rai::parse_endpoint (std::string const & string, rai::endpoint & endpoint_a) -{ - boost::asio::ip::address address; - uint16_t port; - auto result (parse_address_port (string, address, port)); - if (!result) - { - endpoint_a = rai::endpoint (address, port); - } - return result; -} - -bool rai::parse_tcp_endpoint (std::string const & string, rai::tcp_endpoint & endpoint_a) -{ - boost::asio::ip::address address; - uint16_t port; - auto result (parse_address_port (string, address, port)); - if (!result) - { - endpoint_a = rai::tcp_endpoint (address, port); - } - return result; -} diff --git a/rai/node/common.hpp b/rai/node/common.hpp deleted file mode 100644 index 786d188d..00000000 --- a/rai/node/common.hpp +++ /dev/null @@ -1,398 +0,0 @@ -#pragma once - -#include -#include - -#include - -#include - -#include - -namespace rai -{ -using endpoint = boost::asio::ip::udp::endpoint; -bool parse_port (std::string const &, uint16_t &); -bool parse_address_port (std::string const &, boost::asio::ip::address &, uint16_t &); -using tcp_endpoint = boost::asio::ip::tcp::endpoint; -bool parse_endpoint (std::string const &, rai::endpoint &); -bool parse_tcp_endpoint (std::string const &, rai::tcp_endpoint &); -bool reserved_address (rai::endpoint const &, bool); -} - -namespace -{ -uint64_t endpoint_hash_raw (rai::endpoint const & endpoint_a) -{ - assert (endpoint_a.address ().is_v6 ()); - rai::uint128_union address; - address.bytes = endpoint_a.address ().to_v6 ().to_bytes (); - XXH64_state_t hash; - XXH64_reset (&hash, 0); - XXH64_update (&hash, address.bytes.data (), address.bytes.size ()); - auto port (endpoint_a.port ()); - XXH64_update (&hash, &port, sizeof (port)); - auto result (XXH64_digest (&hash)); - return result; -} -uint64_t ip_address_hash_raw (boost::asio::ip::address const & ip_a) -{ - assert (ip_a.is_v6 ()); - rai::uint128_union bytes; - bytes.bytes = ip_a.to_v6 ().to_bytes (); - XXH64_state_t hash; - XXH64_reset (&hash, 0); - XXH64_update (&hash, bytes.bytes.data (), bytes.bytes.size ()); - auto result (XXH64_digest (&hash)); - return result; -} - -template -struct endpoint_hash -{ -}; -template <> -struct endpoint_hash<8> -{ - size_t operator() (rai::endpoint const & endpoint_a) const - { - return endpoint_hash_raw (endpoint_a); - } -}; -template <> -struct endpoint_hash<4> -{ - size_t operator() (rai::endpoint const & endpoint_a) const - { - uint64_t big (endpoint_hash_raw (endpoint_a)); - uint32_t result (static_cast (big) ^ static_cast (big >> 32)); - return result; - } -}; -} - -namespace std -{ -template <> -struct hash -{ - size_t operator() (rai::endpoint const & endpoint_a) const - { - endpoint_hash ehash; - return ehash (endpoint_a); - } -}; -template -struct ip_address_hash -{ -}; -template <> -struct ip_address_hash<8> -{ - size_t operator() (boost::asio::ip::address const & ip_address_a) const - { - return ip_address_hash_raw (ip_address_a); - } -}; -template <> -struct ip_address_hash<4> -{ - size_t operator() (boost::asio::ip::address const & ip_address_a) const - { - uint64_t big (ip_address_hash_raw (ip_address_a)); - uint32_t result (static_cast (big) ^ static_cast (big >> 32)); - return result; - } -}; -template <> -struct hash -{ - size_t operator() (boost::asio::ip::address const & ip_a) const - { - ip_address_hash ihash; - return ihash (ip_a); - } -}; -} -namespace boost -{ -template <> -struct hash -{ - size_t operator() (rai::endpoint const & endpoint_a) const - { - std::hash hash; - return hash (endpoint_a); - } -}; -} - -namespace rai -{ -/** - * Message types are serialized to the network and existing values must thus never change as - * types are added, removed and reordered in the enum. - */ -enum class message_type : uint8_t -{ - invalid = 0x0, - not_a_type = 0x1, - keepalive = 0x2, - publish = 0x3, - confirm_req = 0x4, - confirm_ack = 0x5, - bulk_pull = 0x6, - bulk_push = 0x7, - frontier_req = 0x8, - bulk_pull_blocks = 0x9, - node_id_handshake = 0x0a, - bulk_pull_account = 0x0b -}; -enum class bulk_pull_blocks_mode : uint8_t -{ - list_blocks, - checksum_blocks -}; -enum class bulk_pull_account_flags : uint8_t -{ - pending_hash_and_amount = 0x0, - pending_address_only = 0x1, - pending_hash_amount_and_address = 0x2 -}; -class message_visitor; -class message_header -{ -public: - message_header (rai::message_type); - message_header (bool &, rai::stream &); - void serialize (rai::stream &) const; - bool deserialize (rai::stream &); - rai::block_type block_type () const; - void block_type_set (rai::block_type); - static std::array constexpr magic_number = rai::rai_network == rai::rai_networks::rai_test_network ? std::array{ { 'R', 'A' } } : rai::rai_network == rai::rai_networks::rai_beta_network ? std::array{ { 'R', 'B' } } : std::array{ { 'R', 'C' } }; - uint8_t version_max; - uint8_t version_using; - uint8_t version_min; - rai::message_type type; - std::bitset<16> extensions; - //static size_t constexpr ipv4_only_position = 1; // Not in use, deprecated, was conflicting - //static size_t constexpr bootstrap_server_position = 2; // Not in use, deprecated - /* - * A better approach might be to return the size of the message - * payload based on the header - */ - static size_t constexpr bulk_pull_count_present_flag = 0; - bool bulk_pull_is_count_present () const; - - static std::bitset<16> constexpr block_type_mask = std::bitset<16> (0x0f00); - inline bool valid_magic () const - { - return magic_number[0] == 'R' && magic_number[1] >= 'A' && magic_number[1] <= 'C'; - } - inline bool valid_network () const - { - return (magic_number[1] - 'A') == static_cast (rai::rai_network); - } -}; -class message -{ -public: - message (rai::message_type); - message (rai::message_header const &); - virtual ~message () = default; - virtual void serialize (rai::stream &) const = 0; - virtual void visit (rai::message_visitor &) const = 0; - virtual inline std::shared_ptr> to_bytes () const - { - std::shared_ptr> bytes (new std::vector); - rai::vectorstream stream (*bytes); - serialize (stream); - return bytes; - } - rai::message_header header; -}; -class work_pool; -class message_parser -{ -public: - enum class parse_status - { - success, - insufficient_work, - invalid_header, - invalid_message_type, - invalid_keepalive_message, - invalid_publish_message, - invalid_confirm_req_message, - invalid_confirm_ack_message, - invalid_node_id_handshake_message, - outdated_version, - invalid_magic, - invalid_network - }; - message_parser (rai::block_uniquer &, rai::vote_uniquer &, rai::message_visitor &, rai::work_pool &); - void deserialize_buffer (uint8_t const *, size_t); - void deserialize_keepalive (rai::stream &, rai::message_header const &); - void deserialize_publish (rai::stream &, rai::message_header const &); - void deserialize_confirm_req (rai::stream &, rai::message_header const &); - void deserialize_confirm_ack (rai::stream &, rai::message_header const &); - void deserialize_node_id_handshake (rai::stream &, rai::message_header const &); - bool at_end (rai::stream &); - rai::block_uniquer & block_uniquer; - rai::vote_uniquer & vote_uniquer; - rai::message_visitor & visitor; - rai::work_pool & pool; - parse_status status; - std::string status_string (); - static const size_t max_safe_udp_message_size; -}; -class keepalive : public message -{ -public: - keepalive (bool &, rai::stream &, rai::message_header const &); - keepalive (); - void visit (rai::message_visitor &) const override; - bool deserialize (rai::stream &); - void serialize (rai::stream &) const override; - bool operator== (rai::keepalive const &) const; - std::array peers; -}; -class publish : public message -{ -public: - publish (bool &, rai::stream &, rai::message_header const &, rai::block_uniquer * = nullptr); - publish (std::shared_ptr); - void visit (rai::message_visitor &) const override; - bool deserialize (rai::stream &, rai::block_uniquer * = nullptr); - void serialize (rai::stream &) const override; - bool operator== (rai::publish const &) const; - std::shared_ptr block; -}; -class confirm_req : public message -{ -public: - confirm_req (bool &, rai::stream &, rai::message_header const &, rai::block_uniquer * = nullptr); - confirm_req (std::shared_ptr); - bool deserialize (rai::stream &, rai::block_uniquer * = nullptr); - void serialize (rai::stream &) const override; - void visit (rai::message_visitor &) const override; - bool operator== (rai::confirm_req const &) const; - std::shared_ptr block; -}; -class confirm_ack : public message -{ -public: - confirm_ack (bool &, rai::stream &, rai::message_header const &, rai::vote_uniquer * = nullptr); - confirm_ack (std::shared_ptr); - bool deserialize (rai::stream &, rai::vote_uniquer * = nullptr); - void serialize (rai::stream &) const override; - void visit (rai::message_visitor &) const override; - bool operator== (rai::confirm_ack const &) const; - std::shared_ptr vote; -}; -class frontier_req : public message -{ -public: - frontier_req (); - frontier_req (bool &, rai::stream &, rai::message_header const &); - bool deserialize (rai::stream &); - void serialize (rai::stream &) const override; - void visit (rai::message_visitor &) const override; - bool operator== (rai::frontier_req const &) const; - rai::account start; - uint32_t age; - uint32_t count; -}; -class bulk_pull : public message -{ -public: - typedef uint32_t count_t; - bulk_pull (); - bulk_pull (bool &, rai::stream &, rai::message_header const &); - bool deserialize (rai::stream &); - void serialize (rai::stream &) const override; - void visit (rai::message_visitor &) const override; - rai::uint256_union start; - rai::block_hash end; - count_t count; - bool is_count_present () const; - void set_count_present (bool); - static size_t constexpr count_present_flag = rai::message_header::bulk_pull_count_present_flag; - static size_t constexpr extended_parameters_size = 8; -}; -class bulk_pull_account : public message -{ -public: - bulk_pull_account (); - bulk_pull_account (bool &, rai::stream &, rai::message_header const &); - bool deserialize (rai::stream &); - void serialize (rai::stream &) const override; - void visit (rai::message_visitor &) const override; - rai::uint256_union account; - rai::uint128_union minimum_amount; - bulk_pull_account_flags flags; -}; -class bulk_pull_blocks : public message -{ -public: - bulk_pull_blocks (); - bulk_pull_blocks (bool &, rai::stream &, rai::message_header const &); - bool deserialize (rai::stream &); - void serialize (rai::stream &) const override; - void visit (rai::message_visitor &) const override; - rai::block_hash min_hash; - rai::block_hash max_hash; - bulk_pull_blocks_mode mode; - uint32_t max_count; -}; -class bulk_push : public message -{ -public: - bulk_push (); - bulk_push (rai::message_header const &); - bool deserialize (rai::stream &); - void serialize (rai::stream &) const override; - void visit (rai::message_visitor &) const override; -}; -class node_id_handshake : public message -{ -public: - node_id_handshake (bool &, rai::stream &, rai::message_header const &); - node_id_handshake (boost::optional, boost::optional>); - bool deserialize (rai::stream &); - void serialize (rai::stream &) const override; - void visit (rai::message_visitor &) const override; - bool operator== (rai::node_id_handshake const &) const; - bool is_query_flag () const; - void set_query_flag (bool); - bool is_response_flag () const; - void set_response_flag (bool); - boost::optional query; - boost::optional> response; - static size_t constexpr query_flag = 0; - static size_t constexpr response_flag = 1; -}; -class message_visitor -{ -public: - virtual void keepalive (rai::keepalive const &) = 0; - virtual void publish (rai::publish const &) = 0; - virtual void confirm_req (rai::confirm_req const &) = 0; - virtual void confirm_ack (rai::confirm_ack const &) = 0; - virtual void bulk_pull (rai::bulk_pull const &) = 0; - virtual void bulk_pull_account (rai::bulk_pull_account const &) = 0; - virtual void bulk_pull_blocks (rai::bulk_pull_blocks const &) = 0; - virtual void bulk_push (rai::bulk_push const &) = 0; - virtual void frontier_req (rai::frontier_req const &) = 0; - virtual void node_id_handshake (rai::node_id_handshake const &) = 0; - virtual ~message_visitor (); -}; - -/** - * Returns seconds passed since unix epoch (posix time) - */ -inline uint64_t seconds_since_epoch () -{ - return std::chrono::duration_cast (std::chrono::system_clock::now ().time_since_epoch ()).count (); -} -} diff --git a/rai/node/lmdb.cpp b/rai/node/lmdb.cpp deleted file mode 100644 index 0ed28367..00000000 --- a/rai/node/lmdb.cpp +++ /dev/null @@ -1,1992 +0,0 @@ -#include - -#include -#include -#include - -#include - -#include - -rai::mdb_env::mdb_env (bool & error_a, boost::filesystem::path const & path_a, int max_dbs) -{ - boost::system::error_code error_mkdir, error_chmod; - if (path_a.has_parent_path ()) - { - boost::filesystem::create_directories (path_a.parent_path (), error_mkdir); - rai::set_secure_perm_directory (path_a.parent_path (), error_chmod); - if (!error_mkdir) - { - auto status1 (mdb_env_create (&environment)); - release_assert (status1 == 0); - auto status2 (mdb_env_set_maxdbs (environment, max_dbs)); - release_assert (status2 == 0); - auto status3 (mdb_env_set_mapsize (environment, 1ULL * 1024 * 1024 * 1024 * 128)); // 128 Gigabyte - release_assert (status3 == 0); - // It seems if there's ever more threads than mdb_env_set_maxreaders has read slots available, we get failures on transaction creation unless MDB_NOTLS is specified - // This can happen if something like 256 io_threads are specified in the node config - auto status4 (mdb_env_open (environment, path_a.string ().c_str (), MDB_NOSUBDIR | MDB_NOTLS, 00600)); - release_assert (status4 == 0); - error_a = status4 != 0; - } - else - { - error_a = true; - environment = nullptr; - } - } - else - { - error_a = true; - environment = nullptr; - } -} - -rai::mdb_env::~mdb_env () -{ - if (environment != nullptr) - { - mdb_env_close (environment); - } -} - -rai::mdb_env::operator MDB_env * () const -{ - return environment; -} - -rai::transaction rai::mdb_env::tx_begin (bool write_a) const -{ - return { std::make_unique (*this, write_a) }; -} - -MDB_txn * rai::mdb_env::tx (rai::transaction const & transaction_a) const -{ - auto result (boost::polymorphic_downcast (transaction_a.impl.get ())); - release_assert (mdb_txn_env (result->handle) == environment); - return *result; -} - -rai::mdb_val::mdb_val (rai::epoch epoch_a) : -value ({ 0, nullptr }), -epoch (epoch_a) -{ -} - -rai::mdb_val::mdb_val (MDB_val const & value_a, rai::epoch epoch_a) : -value (value_a), -epoch (epoch_a) -{ -} - -rai::mdb_val::mdb_val (size_t size_a, void * data_a) : -value ({ size_a, data_a }) -{ -} - -rai::mdb_val::mdb_val (rai::uint128_union const & val_a) : -mdb_val (sizeof (val_a), const_cast (&val_a)) -{ -} - -rai::mdb_val::mdb_val (rai::uint256_union const & val_a) : -mdb_val (sizeof (val_a), const_cast (&val_a)) -{ -} - -rai::mdb_val::mdb_val (rai::account_info const & val_a) : -mdb_val (val_a.db_size (), const_cast (&val_a)) -{ -} - -rai::mdb_val::mdb_val (rai::pending_info const & val_a) : -mdb_val (sizeof (val_a.source) + sizeof (val_a.amount), const_cast (&val_a)) -{ -} - -rai::mdb_val::mdb_val (rai::pending_key const & val_a) : -mdb_val (sizeof (val_a), const_cast (&val_a)) -{ -} - -rai::mdb_val::mdb_val (rai::block_info const & val_a) : -mdb_val (sizeof (val_a), const_cast (&val_a)) -{ -} - -rai::mdb_val::mdb_val (std::shared_ptr const & val_a) : -buffer (std::make_shared> ()) -{ - { - rai::vectorstream stream (*buffer); - rai::serialize_block (stream, *val_a); - } - value = { buffer->size (), const_cast (buffer->data ()) }; -} - -void * rai::mdb_val::data () const -{ - return value.mv_data; -} - -size_t rai::mdb_val::size () const -{ - return value.mv_size; -} - -rai::mdb_val::operator rai::account_info () const -{ - rai::account_info result; - result.epoch = epoch; - assert (value.mv_size == result.db_size ()); - std::copy (reinterpret_cast (value.mv_data), reinterpret_cast (value.mv_data) + result.db_size (), reinterpret_cast (&result)); - return result; -} - -rai::mdb_val::operator rai::block_info () const -{ - rai::block_info result; - assert (value.mv_size == sizeof (result)); - static_assert (sizeof (rai::block_info::account) + sizeof (rai::block_info::balance) == sizeof (result), "Packed class"); - std::copy (reinterpret_cast (value.mv_data), reinterpret_cast (value.mv_data) + sizeof (result), reinterpret_cast (&result)); - return result; -} - -rai::mdb_val::operator rai::pending_info () const -{ - rai::pending_info result; - result.epoch = epoch; - std::copy (reinterpret_cast (value.mv_data), reinterpret_cast (value.mv_data) + sizeof (rai::pending_info::source) + sizeof (rai::pending_info::amount), reinterpret_cast (&result)); - return result; -} - -rai::mdb_val::operator rai::pending_key () const -{ - rai::pending_key result; - assert (value.mv_size == sizeof (result)); - static_assert (sizeof (rai::pending_key::account) + sizeof (rai::pending_key::hash) == sizeof (result), "Packed class"); - std::copy (reinterpret_cast (value.mv_data), reinterpret_cast (value.mv_data) + sizeof (result), reinterpret_cast (&result)); - return result; -} - -rai::mdb_val::operator rai::uint128_union () const -{ - rai::uint128_union result; - assert (size () == sizeof (result)); - std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + sizeof (result), result.bytes.data ()); - return result; -} - -rai::mdb_val::operator rai::uint256_union () const -{ - rai::uint256_union result; - assert (size () == sizeof (result)); - std::copy (reinterpret_cast (data ()), reinterpret_cast (data ()) + sizeof (result), result.bytes.data ()); - return result; -} - -rai::mdb_val::operator std::array () const -{ - rai::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); - std::array result; - rai::read (stream, result); - return result; -} - -rai::mdb_val::operator no_value () const -{ - return no_value::dummy; -} - -rai::mdb_val::operator std::shared_ptr () const -{ - rai::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); - std::shared_ptr result (rai::deserialize_block (stream)); - return result; -} - -rai::mdb_val::operator std::shared_ptr () const -{ - rai::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); - auto error (false); - std::shared_ptr result (std::make_shared (error, stream)); - assert (!error); - return result; -} - -rai::mdb_val::operator std::shared_ptr () const -{ - rai::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); - auto error (false); - std::shared_ptr result (std::make_shared (error, stream)); - assert (!error); - return result; -} - -rai::mdb_val::operator std::shared_ptr () const -{ - rai::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); - auto error (false); - std::shared_ptr result (std::make_shared (error, stream)); - assert (!error); - return result; -} - -rai::mdb_val::operator std::shared_ptr () const -{ - rai::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); - auto error (false); - std::shared_ptr result (std::make_shared (error, stream)); - assert (!error); - return result; -} - -rai::mdb_val::operator std::shared_ptr () const -{ - rai::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); - auto error (false); - std::shared_ptr result (std::make_shared (error, stream)); - assert (!error); - return result; -} - -rai::mdb_val::operator std::shared_ptr () const -{ - rai::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); - auto error (false); - std::shared_ptr result (std::make_shared (error, stream)); - assert (!error); - return result; -} - -rai::mdb_val::operator uint64_t () const -{ - uint64_t result; - rai::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); - auto error (rai::read (stream, result)); - assert (!error); - return result; -} - -rai::mdb_val::operator MDB_val * () const -{ - // Allow passing a temporary to a non-c++ function which doesn't have constness - return const_cast (&value); -}; - -rai::mdb_val::operator MDB_val const & () const -{ - return value; -} - -rai::mdb_txn::mdb_txn (rai::mdb_env const & environment_a, bool write_a) -{ - auto status (mdb_txn_begin (environment_a, nullptr, write_a ? 0 : MDB_RDONLY, &handle)); - release_assert (status == 0); -} - -rai::mdb_txn::~mdb_txn () -{ - auto status (mdb_txn_commit (handle)); - release_assert (status == 0); -} - -rai::mdb_txn::operator MDB_txn * () const -{ - return handle; -} - -namespace rai -{ -/** - * Fill in our predecessors - */ -class block_predecessor_set : public rai::block_visitor -{ -public: - block_predecessor_set (rai::transaction const & transaction_a, rai::mdb_store & store_a) : - transaction (transaction_a), - store (store_a) - { - } - virtual ~block_predecessor_set () = default; - void fill_value (rai::block const & block_a) - { - auto hash (block_a.hash ()); - rai::block_type type; - auto value (store.block_raw_get (transaction, block_a.previous (), type)); - auto version (store.block_version (transaction, block_a.previous ())); - assert (value.mv_size != 0); - std::vector data (static_cast (value.mv_data), static_cast (value.mv_data) + value.mv_size); - std::copy (hash.bytes.begin (), hash.bytes.end (), data.end () - hash.bytes.size ()); - store.block_raw_put (transaction, store.block_database (type, version), block_a.previous (), rai::mdb_val (data.size (), data.data ())); - } - void send_block (rai::send_block const & block_a) override - { - fill_value (block_a); - } - void receive_block (rai::receive_block const & block_a) override - { - fill_value (block_a); - } - void open_block (rai::open_block const & block_a) override - { - // Open blocks don't have a predecessor - } - void change_block (rai::change_block const & block_a) override - { - fill_value (block_a); - } - void state_block (rai::state_block const & block_a) override - { - if (!block_a.previous ().is_zero ()) - { - fill_value (block_a); - } - } - rai::transaction const & transaction; - rai::mdb_store & store; -}; -} - -template -rai::mdb_iterator::mdb_iterator (rai::transaction const & transaction_a, MDB_dbi db_a, rai::epoch epoch_a) : -cursor (nullptr) -{ - current.first.epoch = epoch_a; - current.second.epoch = epoch_a; - auto status (mdb_cursor_open (tx (transaction_a), db_a, &cursor)); - release_assert (status == 0); - auto status2 (mdb_cursor_get (cursor, ¤t.first.value, ¤t.second.value, MDB_FIRST)); - release_assert (status2 == 0 || status2 == MDB_NOTFOUND); - if (status2 != MDB_NOTFOUND) - { - auto status3 (mdb_cursor_get (cursor, ¤t.first.value, ¤t.second.value, MDB_GET_CURRENT)); - release_assert (status3 == 0 || status3 == MDB_NOTFOUND); - if (current.first.size () != sizeof (T)) - { - clear (); - } - } - else - { - clear (); - } -} - -template -rai::mdb_iterator::mdb_iterator (std::nullptr_t, rai::epoch epoch_a) : -cursor (nullptr) -{ - current.first.epoch = epoch_a; - current.second.epoch = epoch_a; -} - -template -rai::mdb_iterator::mdb_iterator (rai::transaction const & transaction_a, MDB_dbi db_a, MDB_val const & val_a, rai::epoch epoch_a) : -cursor (nullptr) -{ - current.first.epoch = epoch_a; - current.second.epoch = epoch_a; - auto status (mdb_cursor_open (tx (transaction_a), db_a, &cursor)); - release_assert (status == 0); - current.first = val_a; - auto status2 (mdb_cursor_get (cursor, ¤t.first.value, ¤t.second.value, MDB_SET_RANGE)); - release_assert (status2 == 0 || status2 == MDB_NOTFOUND); - if (status2 != MDB_NOTFOUND) - { - auto status3 (mdb_cursor_get (cursor, ¤t.first.value, ¤t.second.value, MDB_GET_CURRENT)); - release_assert (status3 == 0 || status3 == MDB_NOTFOUND); - if (current.first.size () != sizeof (T)) - { - clear (); - } - } - else - { - clear (); - } -} - -template -rai::mdb_iterator::mdb_iterator (rai::mdb_iterator && other_a) -{ - cursor = other_a.cursor; - other_a.cursor = nullptr; - current = other_a.current; -} - -template -rai::mdb_iterator::~mdb_iterator () -{ - if (cursor != nullptr) - { - mdb_cursor_close (cursor); - } -} - -template -rai::store_iterator_impl & rai::mdb_iterator::operator++ () -{ - assert (cursor != nullptr); - auto status (mdb_cursor_get (cursor, ¤t.first.value, ¤t.second.value, MDB_NEXT)); - release_assert (status == 0 || status == MDB_NOTFOUND); - if (status == MDB_NOTFOUND) - { - clear (); - } - if (current.first.size () != sizeof (T)) - { - clear (); - } - return *this; -} - -template -rai::mdb_iterator & rai::mdb_iterator::operator= (rai::mdb_iterator && other_a) -{ - if (cursor != nullptr) - { - mdb_cursor_close (cursor); - } - cursor = other_a.cursor; - other_a.cursor = nullptr; - current = other_a.current; - other_a.clear (); - return *this; -} - -template -std::pair * rai::mdb_iterator::operator-> () -{ - return ¤t; -} - -template -bool rai::mdb_iterator::operator== (rai::store_iterator_impl const & base_a) const -{ - auto const other_a (boost::polymorphic_downcast const *> (&base_a)); - auto result (current.first.data () == other_a->current.first.data ()); - assert (!result || (current.first.size () == other_a->current.first.size ())); - assert (!result || (current.second.data () == other_a->current.second.data ())); - assert (!result || (current.second.size () == other_a->current.second.size ())); - return result; -} - -template -void rai::mdb_iterator::clear () -{ - current.first = rai::mdb_val (current.first.epoch); - current.second = rai::mdb_val (current.second.epoch); - assert (is_end_sentinal ()); -} - -template -MDB_txn * rai::mdb_iterator::tx (rai::transaction const & transaction_a) const -{ - auto result (boost::polymorphic_downcast (transaction_a.impl.get ())); - return *result; -} - -template -bool rai::mdb_iterator::is_end_sentinal () const -{ - return current.first.size () == 0; -} - -template -void rai::mdb_iterator::fill (std::pair & value_a) const -{ - if (current.first.size () != 0) - { - value_a.first = static_cast (current.first); - } - else - { - value_a.first = T (); - } - if (current.second.size () != 0) - { - value_a.second = static_cast (current.second); - } - else - { - value_a.second = U (); - } -} - -template -std::pair * rai::mdb_merge_iterator::operator-> () -{ - return least_iterator ().operator-> (); -} - -template -rai::mdb_merge_iterator::mdb_merge_iterator (rai::transaction const & transaction_a, MDB_dbi db1_a, MDB_dbi db2_a) : -impl1 (std::make_unique> (transaction_a, db1_a, rai::epoch::epoch_0)), -impl2 (std::make_unique> (transaction_a, db2_a, rai::epoch::epoch_1)) -{ -} - -template -rai::mdb_merge_iterator::mdb_merge_iterator (std::nullptr_t) : -impl1 (std::make_unique> (nullptr, rai::epoch::epoch_0)), -impl2 (std::make_unique> (nullptr, rai::epoch::epoch_1)) -{ -} - -template -rai::mdb_merge_iterator::mdb_merge_iterator (rai::transaction const & transaction_a, MDB_dbi db1_a, MDB_dbi db2_a, MDB_val const & val_a) : -impl1 (std::make_unique> (transaction_a, db1_a, val_a, rai::epoch::epoch_0)), -impl2 (std::make_unique> (transaction_a, db2_a, val_a, rai::epoch::epoch_1)) -{ -} - -template -rai::mdb_merge_iterator::mdb_merge_iterator (rai::mdb_merge_iterator && other_a) -{ - impl1 = std::move (other_a.impl1); - impl2 = std::move (other_a.impl2); -} - -template -rai::mdb_merge_iterator::~mdb_merge_iterator () -{ -} - -template -rai::store_iterator_impl & rai::mdb_merge_iterator::operator++ () -{ - ++least_iterator (); - return *this; -} - -template -bool rai::mdb_merge_iterator::is_end_sentinal () const -{ - return least_iterator ().is_end_sentinal (); -} - -template -void rai::mdb_merge_iterator::fill (std::pair & value_a) const -{ - auto & current (least_iterator ()); - if (current->first.size () != 0) - { - value_a.first = static_cast (current->first); - } - else - { - value_a.first = T (); - } - if (current->second.size () != 0) - { - value_a.second = static_cast (current->second); - } - else - { - value_a.second = U (); - } -} - -template -bool rai::mdb_merge_iterator::operator== (rai::store_iterator_impl const & base_a) const -{ - assert ((dynamic_cast const *> (&base_a) != nullptr) && "Incompatible iterator comparison"); - auto & other (static_cast const &> (base_a)); - return *impl1 == *other.impl1 && *impl2 == *other.impl2; -} - -template -rai::mdb_iterator & rai::mdb_merge_iterator::least_iterator () const -{ - rai::mdb_iterator * result; - if (impl1->is_end_sentinal ()) - { - result = impl2.get (); - } - else if (impl2->is_end_sentinal ()) - { - result = impl1.get (); - } - else - { - auto key_cmp (mdb_cmp (mdb_cursor_txn (impl1->cursor), mdb_cursor_dbi (impl1->cursor), impl1->current.first, impl2->current.first)); - - if (key_cmp < 0) - { - result = impl1.get (); - } - else if (key_cmp > 0) - { - result = impl2.get (); - } - else - { - auto val_cmp (mdb_cmp (mdb_cursor_txn (impl1->cursor), mdb_cursor_dbi (impl1->cursor), impl1->current.second, impl2->current.second)); - result = val_cmp < 0 ? impl1.get () : impl2.get (); - } - } - return *result; -} - -rai::wallet_value::wallet_value (rai::mdb_val const & val_a) -{ - assert (val_a.size () == sizeof (*this)); - std::copy (reinterpret_cast (val_a.data ()), reinterpret_cast (val_a.data ()) + sizeof (key), key.chars.begin ()); - std::copy (reinterpret_cast (val_a.data ()) + sizeof (key), reinterpret_cast (val_a.data ()) + sizeof (key) + sizeof (work), reinterpret_cast (&work)); -} - -rai::wallet_value::wallet_value (rai::uint256_union const & key_a, uint64_t work_a) : -key (key_a), -work (work_a) -{ -} - -rai::mdb_val rai::wallet_value::val () const -{ - static_assert (sizeof (*this) == sizeof (key) + sizeof (work), "Class not packed"); - return rai::mdb_val (sizeof (*this), const_cast (this)); -} - -template class rai::mdb_iterator; -template class rai::mdb_iterator; -template class rai::mdb_iterator; -template class rai::mdb_iterator; -template class rai::mdb_iterator>; -template class rai::mdb_iterator>; -template class rai::mdb_iterator; -template class rai::mdb_iterator, rai::mdb_val::no_value>; - -rai::store_iterator rai::mdb_store::block_info_begin (rai::transaction const & transaction_a, rai::block_hash const & hash_a) -{ - rai::store_iterator result (std::make_unique> (transaction_a, blocks_info, rai::mdb_val (hash_a))); - return result; -} - -rai::store_iterator rai::mdb_store::block_info_begin (rai::transaction const & transaction_a) -{ - rai::store_iterator result (std::make_unique> (transaction_a, blocks_info)); - return result; -} - -rai::store_iterator rai::mdb_store::block_info_end () -{ - rai::store_iterator result (nullptr); - return result; -} - -rai::store_iterator rai::mdb_store::representation_begin (rai::transaction const & transaction_a) -{ - rai::store_iterator result (std::make_unique> (transaction_a, representation)); - return result; -} - -rai::store_iterator rai::mdb_store::representation_end () -{ - rai::store_iterator result (nullptr); - return result; -} - -rai::store_iterator> rai::mdb_store::unchecked_begin (rai::transaction const & transaction_a) -{ - rai::store_iterator> result (std::make_unique>> (transaction_a, unchecked)); - return result; -} - -rai::store_iterator> rai::mdb_store::unchecked_begin (rai::transaction const & transaction_a, rai::unchecked_key const & key_a) -{ - rai::store_iterator> result (std::make_unique>> (transaction_a, unchecked, rai::mdb_val (key_a))); - return result; -} - -rai::store_iterator> rai::mdb_store::unchecked_end () -{ - rai::store_iterator> result (nullptr); - return result; -} - -rai::store_iterator> rai::mdb_store::vote_begin (rai::transaction const & transaction_a) -{ - return rai::store_iterator> (std::make_unique>> (transaction_a, vote)); -} - -rai::store_iterator> rai::mdb_store::vote_end () -{ - return rai::store_iterator> (nullptr); -} - -rai::mdb_store::mdb_store (bool & error_a, boost::filesystem::path const & path_a, int lmdb_max_dbs) : -env (error_a, path_a, lmdb_max_dbs), -frontiers (0), -accounts_v0 (0), -accounts_v1 (0), -send_blocks (0), -receive_blocks (0), -open_blocks (0), -change_blocks (0), -state_blocks_v0 (0), -state_blocks_v1 (0), -pending_v0 (0), -pending_v1 (0), -blocks_info (0), -representation (0), -unchecked (0), -checksum (0), -vote (0), -meta (0) -{ - if (!error_a) - { - auto transaction (tx_begin_write ()); - error_a |= mdb_dbi_open (env.tx (transaction), "frontiers", MDB_CREATE, &frontiers) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "accounts", MDB_CREATE, &accounts_v0) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "accounts_v1", MDB_CREATE, &accounts_v1) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "send", MDB_CREATE, &send_blocks) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "receive", MDB_CREATE, &receive_blocks) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "open", MDB_CREATE, &open_blocks) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "change", MDB_CREATE, &change_blocks) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "state", MDB_CREATE, &state_blocks_v0) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "state_v1", MDB_CREATE, &state_blocks_v1) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "pending", MDB_CREATE, &pending_v0) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "pending_v1", MDB_CREATE, &pending_v1) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "blocks_info", MDB_CREATE, &blocks_info) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "representation", MDB_CREATE, &representation) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "unchecked", MDB_CREATE, &unchecked) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "checksum", MDB_CREATE, &checksum) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "vote", MDB_CREATE, &vote) != 0; - error_a |= mdb_dbi_open (env.tx (transaction), "meta", MDB_CREATE, &meta) != 0; - if (!error_a) - { - do_upgrades (transaction); - checksum_put (transaction, 0, 0, 0); - } - } -} - -rai::transaction rai::mdb_store::tx_begin_write () -{ - return tx_begin (true); -} - -rai::transaction rai::mdb_store::tx_begin_read () -{ - return tx_begin (false); -} - -rai::transaction rai::mdb_store::tx_begin (bool write_a) -{ - return env.tx_begin (write_a); -} - -void rai::mdb_store::initialize (rai::transaction const & transaction_a, rai::genesis const & genesis_a) -{ - auto hash_l (genesis_a.hash ()); - assert (latest_v0_begin (transaction_a) == latest_v0_end ()); - assert (latest_v1_begin (transaction_a) == latest_v1_end ()); - block_put (transaction_a, hash_l, *genesis_a.open); - account_put (transaction_a, genesis_account, { hash_l, genesis_a.open->hash (), genesis_a.open->hash (), std::numeric_limits::max (), rai::seconds_since_epoch (), 1, rai::epoch::epoch_0 }); - representation_put (transaction_a, genesis_account, std::numeric_limits::max ()); - checksum_put (transaction_a, 0, 0, hash_l); - frontier_put (transaction_a, hash_l, genesis_account); -} - -void rai::mdb_store::version_put (rai::transaction const & transaction_a, int version_a) -{ - rai::uint256_union version_key (1); - rai::uint256_union version_value (version_a); - auto status (mdb_put (env.tx (transaction_a), meta, rai::mdb_val (version_key), rai::mdb_val (version_value), 0)); - release_assert (status == 0); -} - -int rai::mdb_store::version_get (rai::transaction const & transaction_a) -{ - rai::uint256_union version_key (1); - rai::mdb_val data; - auto error (mdb_get (env.tx (transaction_a), meta, rai::mdb_val (version_key), data)); - int result (1); - if (error != MDB_NOTFOUND) - { - rai::uint256_union version_value (data); - assert (version_value.qwords[2] == 0 && version_value.qwords[1] == 0 && version_value.qwords[0] == 0); - result = version_value.number ().convert_to (); - } - return result; -} - -rai::raw_key rai::mdb_store::get_node_id (rai::transaction const & transaction_a) -{ - rai::uint256_union node_id_mdb_key (3); - rai::raw_key node_id; - rai::mdb_val value; - auto error (mdb_get (env.tx (transaction_a), meta, rai::mdb_val (node_id_mdb_key), value)); - if (!error) - { - rai::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); - error = rai::read (stream, node_id.data); - assert (!error); - } - if (error) - { - rai::random_pool.GenerateBlock (node_id.data.bytes.data (), node_id.data.bytes.size ()); - error = mdb_put (env.tx (transaction_a), meta, rai::mdb_val (node_id_mdb_key), rai::mdb_val (node_id.data), 0); - } - assert (!error); - return node_id; -} - -void rai::mdb_store::delete_node_id (rai::transaction const & transaction_a) -{ - rai::uint256_union node_id_mdb_key (3); - auto error (mdb_del (env.tx (transaction_a), meta, rai::mdb_val (node_id_mdb_key), nullptr)); - assert (!error || error == MDB_NOTFOUND); -} - -void rai::mdb_store::do_upgrades (rai::transaction const & transaction_a) -{ - switch (version_get (transaction_a)) - { - case 1: - upgrade_v1_to_v2 (transaction_a); - case 2: - upgrade_v2_to_v3 (transaction_a); - case 3: - upgrade_v3_to_v4 (transaction_a); - case 4: - upgrade_v4_to_v5 (transaction_a); - case 5: - upgrade_v5_to_v6 (transaction_a); - case 6: - upgrade_v6_to_v7 (transaction_a); - case 7: - upgrade_v7_to_v8 (transaction_a); - case 8: - upgrade_v8_to_v9 (transaction_a); - case 9: - upgrade_v9_to_v10 (transaction_a); - case 10: - upgrade_v10_to_v11 (transaction_a); - case 11: - upgrade_v11_to_v12 (transaction_a); - case 12: - break; - default: - assert (false); - } -} - -void rai::mdb_store::upgrade_v1_to_v2 (rai::transaction const & transaction_a) -{ - version_put (transaction_a, 2); - rai::account account (1); - while (!account.is_zero ()) - { - rai::mdb_iterator i (transaction_a, accounts_v0, rai::mdb_val (account)); - std::cerr << std::hex; - if (i != rai::mdb_iterator (nullptr)) - { - account = rai::uint256_union (i->first); - rai::account_info_v1 v1 (i->second); - rai::account_info_v5 v2; - v2.balance = v1.balance; - v2.head = v1.head; - v2.modified = v1.modified; - v2.rep_block = v1.rep_block; - auto block (block_get (transaction_a, v1.head)); - while (!block->previous ().is_zero ()) - { - block = block_get (transaction_a, block->previous ()); - } - v2.open_block = block->hash (); - auto status (mdb_put (env.tx (transaction_a), accounts_v0, rai::mdb_val (account), v2.val (), 0)); - release_assert (status == 0); - account = account.number () + 1; - } - else - { - account.clear (); - } - } -} - -void rai::mdb_store::upgrade_v2_to_v3 (rai::transaction const & transaction_a) -{ - version_put (transaction_a, 3); - mdb_drop (env.tx (transaction_a), representation, 0); - for (auto i (std::make_unique> (transaction_a, accounts_v0)), n (std::make_unique> (nullptr)); *i != *n; ++(*i)) - { - rai::account account_l ((*i)->first); - rai::account_info_v5 info ((*i)->second); - representative_visitor visitor (transaction_a, *this); - visitor.compute (info.head); - assert (!visitor.result.is_zero ()); - info.rep_block = visitor.result; - auto impl (boost::polymorphic_downcast *> (i.get ())); - mdb_cursor_put (impl->cursor, rai::mdb_val (account_l), info.val (), MDB_CURRENT); - representation_add (transaction_a, visitor.result, info.balance.number ()); - } -} - -void rai::mdb_store::upgrade_v3_to_v4 (rai::transaction const & transaction_a) -{ - version_put (transaction_a, 4); - std::queue> items; - for (auto i (rai::store_iterator (std::make_unique> (transaction_a, pending_v0))), n (rai::store_iterator (nullptr)); i != n; ++i) - { - rai::block_hash hash (i->first); - rai::pending_info_v3 info (i->second); - items.push (std::make_pair (rai::pending_key (info.destination, hash), rai::pending_info (info.source, info.amount, rai::epoch::epoch_0))); - } - mdb_drop (env.tx (transaction_a), pending_v0, 0); - while (!items.empty ()) - { - pending_put (transaction_a, items.front ().first, items.front ().second); - items.pop (); - } -} - -void rai::mdb_store::upgrade_v4_to_v5 (rai::transaction const & transaction_a) -{ - version_put (transaction_a, 5); - for (auto i (rai::store_iterator (std::make_unique> (transaction_a, accounts_v0))), n (rai::store_iterator (nullptr)); i != n; ++i) - { - rai::account_info_v5 info (i->second); - rai::block_hash successor (0); - auto block (block_get (transaction_a, info.head)); - while (block != nullptr) - { - auto hash (block->hash ()); - if (block_successor (transaction_a, hash).is_zero () && !successor.is_zero ()) - { - block_put (transaction_a, hash, *block, successor); - } - successor = hash; - block = block_get (transaction_a, block->previous ()); - } - } -} - -void rai::mdb_store::upgrade_v5_to_v6 (rai::transaction const & transaction_a) -{ - version_put (transaction_a, 6); - std::deque> headers; - for (auto i (rai::store_iterator (std::make_unique> (transaction_a, accounts_v0))), n (rai::store_iterator (nullptr)); i != n; ++i) - { - rai::account account (i->first); - rai::account_info_v5 info_old (i->second); - uint64_t block_count (0); - auto hash (info_old.head); - while (!hash.is_zero ()) - { - ++block_count; - auto block (block_get (transaction_a, hash)); - assert (block != nullptr); - hash = block->previous (); - } - rai::account_info info (info_old.head, info_old.rep_block, info_old.open_block, info_old.balance, info_old.modified, block_count, rai::epoch::epoch_0); - headers.push_back (std::make_pair (account, info)); - } - for (auto i (headers.begin ()), n (headers.end ()); i != n; ++i) - { - account_put (transaction_a, i->first, i->second); - } -} - -void rai::mdb_store::upgrade_v6_to_v7 (rai::transaction const & transaction_a) -{ - version_put (transaction_a, 7); - mdb_drop (env.tx (transaction_a), unchecked, 0); -} - -void rai::mdb_store::upgrade_v7_to_v8 (rai::transaction const & transaction_a) -{ - version_put (transaction_a, 8); - mdb_drop (env.tx (transaction_a), unchecked, 1); - mdb_dbi_open (env.tx (transaction_a), "unchecked", MDB_CREATE | MDB_DUPSORT, &unchecked); -} - -void rai::mdb_store::upgrade_v8_to_v9 (rai::transaction const & transaction_a) -{ - version_put (transaction_a, 9); - MDB_dbi sequence; - mdb_dbi_open (env.tx (transaction_a), "sequence", MDB_CREATE | MDB_DUPSORT, &sequence); - rai::genesis genesis; - std::shared_ptr block (std::move (genesis.open)); - rai::keypair junk; - for (rai::mdb_iterator i (transaction_a, sequence), n (rai::mdb_iterator (nullptr)); i != n; ++i) - { - rai::bufferstream stream (reinterpret_cast (i->second.data ()), i->second.size ()); - uint64_t sequence; - auto error (rai::read (stream, sequence)); - // Create a dummy vote with the same sequence number for easy upgrading. This won't have a valid signature. - rai::vote dummy (rai::account (i->first), junk.prv, sequence, block); - std::vector vector; - { - rai::vectorstream stream (vector); - dummy.serialize (stream); - } - auto status1 (mdb_put (env.tx (transaction_a), vote, rai::mdb_val (i->first), rai::mdb_val (vector.size (), vector.data ()), 0)); - release_assert (status1 == 0); - assert (!error); - } - mdb_drop (env.tx (transaction_a), sequence, 1); -} - -void rai::mdb_store::upgrade_v9_to_v10 (rai::transaction const & transaction_a) -{ - //std::cerr << boost::str (boost::format ("Performing database upgrade to version 10...\n")); - version_put (transaction_a, 10); - for (auto i (latest_v0_begin (transaction_a)), n (latest_v0_end ()); i != n; ++i) - { - rai::account_info info (i->second); - if (info.block_count >= block_info_max) - { - rai::account account (i->first); - //std::cerr << boost::str (boost::format ("Upgrading account %1%...\n") % account.to_account ()); - size_t block_count (1); - auto hash (info.open_block); - while (!hash.is_zero ()) - { - if ((block_count % block_info_max) == 0) - { - rai::block_info block_info; - block_info.account = account; - rai::amount balance (block_balance (transaction_a, hash)); - block_info.balance = balance; - block_info_put (transaction_a, hash, block_info); - } - hash = block_successor (transaction_a, hash); - ++block_count; - } - } - } -} - -void rai::mdb_store::upgrade_v10_to_v11 (rai::transaction const & transaction_a) -{ - version_put (transaction_a, 11); - MDB_dbi unsynced; - mdb_dbi_open (env.tx (transaction_a), "unsynced", MDB_CREATE | MDB_DUPSORT, &unsynced); - mdb_drop (env.tx (transaction_a), unsynced, 1); -} - -void rai::mdb_store::upgrade_v11_to_v12 (rai::transaction const & transaction_a) -{ - version_put (transaction_a, 12); - mdb_drop (env.tx (transaction_a), unchecked, 1); - mdb_dbi_open (env.tx (transaction_a), "unchecked", MDB_CREATE, &unchecked); -} - -void rai::mdb_store::clear (MDB_dbi db_a) -{ - auto transaction (tx_begin_write ()); - auto status (mdb_drop (env.tx (transaction), db_a, 0)); - release_assert (status == 0); -} - -rai::uint128_t rai::mdb_store::block_balance (rai::transaction const & transaction_a, rai::block_hash const & hash_a) -{ - summation_visitor visitor (transaction_a, *this); - return visitor.compute_balance (hash_a); -} - -rai::epoch rai::mdb_store::block_version (rai::transaction const & transaction_a, rai::block_hash const & hash_a) -{ - rai::mdb_val value; - auto status (mdb_get (env.tx (transaction_a), state_blocks_v1, rai::mdb_val (hash_a), value)); - release_assert (status == 0 || status == MDB_NOTFOUND); - return status == 0 ? rai::epoch::epoch_1 : rai::epoch::epoch_0; -} - -void rai::mdb_store::representation_add (rai::transaction const & transaction_a, rai::block_hash const & source_a, rai::uint128_t const & amount_a) -{ - auto source_block (block_get (transaction_a, source_a)); - assert (source_block != nullptr); - auto source_rep (source_block->representative ()); - auto source_previous (representation_get (transaction_a, source_rep)); - representation_put (transaction_a, source_rep, source_previous + amount_a); -} - -MDB_dbi rai::mdb_store::block_database (rai::block_type type_a, rai::epoch epoch_a) -{ - if (type_a == rai::block_type::state) - { - assert (epoch_a == rai::epoch::epoch_0 || epoch_a == rai::epoch::epoch_1); - } - else - { - assert (epoch_a == rai::epoch::epoch_0); - } - MDB_dbi result; - switch (type_a) - { - case rai::block_type::send: - result = send_blocks; - break; - case rai::block_type::receive: - result = receive_blocks; - break; - case rai::block_type::open: - result = open_blocks; - break; - case rai::block_type::change: - result = change_blocks; - break; - case rai::block_type::state: - switch (epoch_a) - { - case rai::epoch::epoch_0: - result = state_blocks_v0; - break; - case rai::epoch::epoch_1: - result = state_blocks_v1; - break; - default: - assert (false); - } - break; - default: - assert (false); - break; - } - return result; -} - -void rai::mdb_store::block_raw_put (rai::transaction const & transaction_a, MDB_dbi database_a, rai::block_hash const & hash_a, MDB_val value_a) -{ - auto status2 (mdb_put (env.tx (transaction_a), database_a, rai::mdb_val (hash_a), &value_a, 0)); - release_assert (status2 == 0); -} - -void rai::mdb_store::block_put (rai::transaction const & transaction_a, rai::block_hash const & hash_a, rai::block const & block_a, rai::block_hash const & successor_a, rai::epoch epoch_a) -{ - assert (successor_a.is_zero () || block_exists (transaction_a, successor_a)); - std::vector vector; - { - rai::vectorstream stream (vector); - block_a.serialize (stream); - rai::write (stream, successor_a.bytes); - } - block_raw_put (transaction_a, block_database (block_a.type (), epoch_a), hash_a, { vector.size (), vector.data () }); - rai::block_predecessor_set predecessor (transaction_a, *this); - block_a.visit (predecessor); - assert (block_a.previous ().is_zero () || block_successor (transaction_a, block_a.previous ()) == hash_a); -} - -MDB_val rai::mdb_store::block_raw_get (rai::transaction const & transaction_a, rai::block_hash const & hash_a, rai::block_type & type_a) -{ - rai::mdb_val result; - auto status (mdb_get (env.tx (transaction_a), send_blocks, rai::mdb_val (hash_a), result)); - release_assert (status == 0 || status == MDB_NOTFOUND); - if (status != 0) - { - auto status (mdb_get (env.tx (transaction_a), receive_blocks, rai::mdb_val (hash_a), result)); - release_assert (status == 0 || status == MDB_NOTFOUND); - if (status != 0) - { - auto status (mdb_get (env.tx (transaction_a), open_blocks, rai::mdb_val (hash_a), result)); - release_assert (status == 0 || status == MDB_NOTFOUND); - if (status != 0) - { - auto status (mdb_get (env.tx (transaction_a), change_blocks, rai::mdb_val (hash_a), result)); - release_assert (status == 0 || status == MDB_NOTFOUND); - if (status != 0) - { - auto status (mdb_get (env.tx (transaction_a), state_blocks_v0, rai::mdb_val (hash_a), result)); - release_assert (status == 0 || status == MDB_NOTFOUND); - if (status != 0) - { - auto status (mdb_get (env.tx (transaction_a), state_blocks_v1, rai::mdb_val (hash_a), result)); - release_assert (status == 0 || status == MDB_NOTFOUND); - if (status != 0) - { - // Block not found - } - else - { - type_a = rai::block_type::state; - } - } - else - { - type_a = rai::block_type::state; - } - } - else - { - type_a = rai::block_type::change; - } - } - else - { - type_a = rai::block_type::open; - } - } - else - { - type_a = rai::block_type::receive; - } - } - else - { - type_a = rai::block_type::send; - } - return result; -} - -template -std::shared_ptr rai::mdb_store::block_random (rai::transaction const & transaction_a, MDB_dbi database) -{ - rai::block_hash hash; - rai::random_pool.GenerateBlock (hash.bytes.data (), hash.bytes.size ()); - rai::store_iterator> existing (std::make_unique>> (transaction_a, database, rai::mdb_val (hash))); - if (existing == rai::store_iterator> (nullptr)) - { - existing = rai::store_iterator> (std::make_unique>> (transaction_a, database)); - } - auto end (rai::store_iterator> (nullptr)); - assert (existing != end); - return block_get (transaction_a, rai::block_hash (existing->first)); -} - -std::shared_ptr rai::mdb_store::block_random (rai::transaction const & transaction_a) -{ - auto count (block_count (transaction_a)); - auto region (rai::random_pool.GenerateWord32 (0, count.sum () - 1)); - std::shared_ptr result; - if (region < count.send) - { - result = block_random (transaction_a, send_blocks); - } - else - { - region -= count.send; - if (region < count.receive) - { - result = block_random (transaction_a, receive_blocks); - } - else - { - region -= count.receive; - if (region < count.open) - { - result = block_random (transaction_a, open_blocks); - } - else - { - region -= count.open; - if (region < count.change) - { - result = block_random (transaction_a, change_blocks); - } - else - { - region -= count.change; - if (region < count.state_v0) - { - result = block_random (transaction_a, state_blocks_v0); - } - else - { - result = block_random (transaction_a, state_blocks_v1); - } - } - } - } - } - assert (result != nullptr); - return result; -} - -rai::block_hash rai::mdb_store::block_successor (rai::transaction const & transaction_a, rai::block_hash const & hash_a) -{ - rai::block_type type; - auto value (block_raw_get (transaction_a, hash_a, type)); - rai::block_hash result; - if (value.mv_size != 0) - { - assert (value.mv_size >= result.bytes.size ()); - rai::bufferstream stream (reinterpret_cast (value.mv_data) + value.mv_size - result.bytes.size (), result.bytes.size ()); - auto error (rai::read (stream, result.bytes)); - assert (!error); - } - else - { - result.clear (); - } - return result; -} - -void rai::mdb_store::block_successor_clear (rai::transaction const & transaction_a, rai::block_hash const & hash_a) -{ - auto block (block_get (transaction_a, hash_a)); - auto version (block_version (transaction_a, hash_a)); - block_put (transaction_a, hash_a, *block, 0, version); -} - -std::shared_ptr rai::mdb_store::block_get (rai::transaction const & transaction_a, rai::block_hash const & hash_a) -{ - rai::block_type type; - auto value (block_raw_get (transaction_a, hash_a, type)); - std::shared_ptr result; - if (value.mv_size != 0) - { - rai::bufferstream stream (reinterpret_cast (value.mv_data), value.mv_size); - result = rai::deserialize_block (stream, type); - assert (result != nullptr); - } - return result; -} - -void rai::mdb_store::block_del (rai::transaction const & transaction_a, rai::block_hash const & hash_a) -{ - auto status (mdb_del (env.tx (transaction_a), state_blocks_v1, rai::mdb_val (hash_a), nullptr)); - release_assert (status == 0 || status == MDB_NOTFOUND); - if (status != 0) - { - auto status (mdb_del (env.tx (transaction_a), state_blocks_v0, rai::mdb_val (hash_a), nullptr)); - release_assert (status == 0 || status == MDB_NOTFOUND); - if (status != 0) - { - auto status (mdb_del (env.tx (transaction_a), send_blocks, rai::mdb_val (hash_a), nullptr)); - release_assert (status == 0 || status == MDB_NOTFOUND); - if (status != 0) - { - auto status (mdb_del (env.tx (transaction_a), receive_blocks, rai::mdb_val (hash_a), nullptr)); - release_assert (status == 0 || status == MDB_NOTFOUND); - if (status != 0) - { - auto status (mdb_del (env.tx (transaction_a), open_blocks, rai::mdb_val (hash_a), nullptr)); - release_assert (status == 0 || status == MDB_NOTFOUND); - if (status != 0) - { - auto status (mdb_del (env.tx (transaction_a), change_blocks, rai::mdb_val (hash_a), nullptr)); - release_assert (status == 0); - } - } - } - } - } -} - -bool rai::mdb_store::block_exists (rai::transaction const & transaction_a, rai::block_type type, rai::block_hash const & hash_a) -{ - auto exists (false); - rai::mdb_val junk; - - switch (type) - { - case rai::block_type::send: - { - auto status (mdb_get (env.tx (transaction_a), send_blocks, rai::mdb_val (hash_a), junk)); - assert (status == 0 || status == MDB_NOTFOUND); - exists = status == 0; - break; - } - case rai::block_type::receive: - { - auto status (mdb_get (env.tx (transaction_a), receive_blocks, rai::mdb_val (hash_a), junk)); - release_assert (status == 0 || status == MDB_NOTFOUND); - exists = status == 0; - break; - } - case rai::block_type::open: - { - auto status (mdb_get (env.tx (transaction_a), open_blocks, rai::mdb_val (hash_a), junk)); - release_assert (status == 0 || status == MDB_NOTFOUND); - exists = status == 0; - break; - } - case rai::block_type::change: - { - auto status (mdb_get (env.tx (transaction_a), change_blocks, rai::mdb_val (hash_a), junk)); - release_assert (status == 0 || status == MDB_NOTFOUND); - exists = status == 0; - break; - } - case rai::block_type::state: - { - auto status (mdb_get (env.tx (transaction_a), state_blocks_v0, rai::mdb_val (hash_a), junk)); - release_assert (status == 0 || status == MDB_NOTFOUND); - exists = status == 0; - if (!exists) - { - auto status (mdb_get (env.tx (transaction_a), state_blocks_v1, rai::mdb_val (hash_a), junk)); - release_assert (status == 0 || status == MDB_NOTFOUND); - exists = status == 0; - } - break; - } - case rai::block_type::invalid: - case rai::block_type::not_a_block: - break; - } - - return exists; -} - -bool rai::mdb_store::block_exists (rai::transaction const & tx_a, rai::block_hash const & hash_a) -{ - // clang-format off - return - block_exists (tx_a, rai::block_type::send, hash_a) || - block_exists (tx_a, rai::block_type::receive, hash_a) || - block_exists (tx_a, rai::block_type::open, hash_a) || - block_exists (tx_a, rai::block_type::change, hash_a) || - block_exists (tx_a, rai::block_type::state, hash_a); - // clang-format on -} - -rai::block_counts rai::mdb_store::block_count (rai::transaction const & transaction_a) -{ - rai::block_counts result; - MDB_stat send_stats; - auto status1 (mdb_stat (env.tx (transaction_a), send_blocks, &send_stats)); - release_assert (status1 == 0); - MDB_stat receive_stats; - auto status2 (mdb_stat (env.tx (transaction_a), receive_blocks, &receive_stats)); - release_assert (status2 == 0); - MDB_stat open_stats; - auto status3 (mdb_stat (env.tx (transaction_a), open_blocks, &open_stats)); - release_assert (status3 == 0); - MDB_stat change_stats; - auto status4 (mdb_stat (env.tx (transaction_a), change_blocks, &change_stats)); - release_assert (status4 == 0); - MDB_stat state_v0_stats; - auto status5 (mdb_stat (env.tx (transaction_a), state_blocks_v0, &state_v0_stats)); - release_assert (status5 == 0); - MDB_stat state_v1_stats; - auto status6 (mdb_stat (env.tx (transaction_a), state_blocks_v1, &state_v1_stats)); - release_assert (status6 == 0); - result.send = send_stats.ms_entries; - result.receive = receive_stats.ms_entries; - result.open = open_stats.ms_entries; - result.change = change_stats.ms_entries; - result.state_v0 = state_v0_stats.ms_entries; - result.state_v1 = state_v1_stats.ms_entries; - return result; -} - -bool rai::mdb_store::root_exists (rai::transaction const & transaction_a, rai::uint256_union const & root_a) -{ - return block_exists (transaction_a, root_a) || account_exists (transaction_a, root_a); -} - -void rai::mdb_store::account_del (rai::transaction const & transaction_a, rai::account const & account_a) -{ - auto status1 (mdb_del (env.tx (transaction_a), accounts_v1, rai::mdb_val (account_a), nullptr)); - if (status1 != 0) - { - release_assert (status1 == MDB_NOTFOUND); - auto status2 (mdb_del (env.tx (transaction_a), accounts_v0, rai::mdb_val (account_a), nullptr)); - release_assert (status2 == 0); - } -} - -bool rai::mdb_store::account_exists (rai::transaction const & transaction_a, rai::account const & account_a) -{ - auto iterator (latest_begin (transaction_a, account_a)); - return iterator != latest_end () && rai::account (iterator->first) == account_a; -} - -bool rai::mdb_store::account_get (rai::transaction const & transaction_a, rai::account const & account_a, rai::account_info & info_a) -{ - rai::mdb_val value; - auto status1 (mdb_get (env.tx (transaction_a), accounts_v1, rai::mdb_val (account_a), value)); - release_assert (status1 == 0 || status1 == MDB_NOTFOUND); - bool result (false); - rai::epoch epoch; - if (status1 == 0) - { - epoch = rai::epoch::epoch_1; - } - else - { - auto status2 (mdb_get (env.tx (transaction_a), accounts_v0, rai::mdb_val (account_a), value)); - release_assert (status2 == 0 || status2 == MDB_NOTFOUND); - if (status2 == 0) - { - epoch = rai::epoch::epoch_0; - } - else - { - result = true; - } - } - if (!result) - { - rai::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); - info_a.epoch = epoch; - info_a.deserialize (stream); - } - return result; -} - -void rai::mdb_store::frontier_put (rai::transaction const & transaction_a, rai::block_hash const & block_a, rai::account const & account_a) -{ - auto status (mdb_put (env.tx (transaction_a), frontiers, rai::mdb_val (block_a), rai::mdb_val (account_a), 0)); - release_assert (status == 0); -} - -rai::account rai::mdb_store::frontier_get (rai::transaction const & transaction_a, rai::block_hash const & block_a) -{ - rai::mdb_val value; - auto status (mdb_get (env.tx (transaction_a), frontiers, rai::mdb_val (block_a), value)); - release_assert (status == 0 || status == MDB_NOTFOUND); - rai::account result (0); - if (status == 0) - { - result = rai::uint256_union (value); - } - return result; -} - -void rai::mdb_store::frontier_del (rai::transaction const & transaction_a, rai::block_hash const & block_a) -{ - auto status (mdb_del (env.tx (transaction_a), frontiers, rai::mdb_val (block_a), nullptr)); - release_assert (status == 0); -} - -size_t rai::mdb_store::account_count (rai::transaction const & transaction_a) -{ - MDB_stat stats1; - auto status1 (mdb_stat (env.tx (transaction_a), accounts_v0, &stats1)); - release_assert (status1 == 0); - MDB_stat stats2; - auto status2 (mdb_stat (env.tx (transaction_a), accounts_v1, &stats2)); - release_assert (status2 == 0); - auto result (stats1.ms_entries + stats2.ms_entries); - return result; -} - -void rai::mdb_store::account_put (rai::transaction const & transaction_a, rai::account const & account_a, rai::account_info const & info_a) -{ - MDB_dbi db; - switch (info_a.epoch) - { - case rai::epoch::invalid: - case rai::epoch::unspecified: - assert (false); - case rai::epoch::epoch_0: - db = accounts_v0; - break; - case rai::epoch::epoch_1: - db = accounts_v1; - break; - } - auto status (mdb_put (env.tx (transaction_a), db, rai::mdb_val (account_a), rai::mdb_val (info_a), 0)); - release_assert (status == 0); -} - -void rai::mdb_store::pending_put (rai::transaction const & transaction_a, rai::pending_key const & key_a, rai::pending_info const & pending_a) -{ - MDB_dbi db; - switch (pending_a.epoch) - { - case rai::epoch::invalid: - case rai::epoch::unspecified: - assert (false); - case rai::epoch::epoch_0: - db = pending_v0; - break; - case rai::epoch::epoch_1: - db = pending_v1; - break; - } - auto status (mdb_put (env.tx (transaction_a), db, rai::mdb_val (key_a), rai::mdb_val (pending_a), 0)); - release_assert (status == 0); -} - -void rai::mdb_store::pending_del (rai::transaction const & transaction_a, rai::pending_key const & key_a) -{ - auto status1 (mdb_del (env.tx (transaction_a), pending_v1, mdb_val (key_a), nullptr)); - if (status1 != 0) - { - release_assert (status1 == MDB_NOTFOUND); - auto status2 (mdb_del (env.tx (transaction_a), pending_v0, mdb_val (key_a), nullptr)); - release_assert (status2 == 0); - } -} - -bool rai::mdb_store::pending_exists (rai::transaction const & transaction_a, rai::pending_key const & key_a) -{ - auto iterator (pending_begin (transaction_a, key_a)); - return iterator != pending_end () && rai::pending_key (iterator->first) == key_a; -} - -bool rai::mdb_store::pending_get (rai::transaction const & transaction_a, rai::pending_key const & key_a, rai::pending_info & pending_a) -{ - rai::mdb_val value; - auto status1 (mdb_get (env.tx (transaction_a), pending_v1, mdb_val (key_a), value)); - release_assert (status1 == 0 || status1 == MDB_NOTFOUND); - bool result (false); - rai::epoch epoch; - if (status1 == 0) - { - epoch = rai::epoch::epoch_1; - } - else - { - auto status2 (mdb_get (env.tx (transaction_a), pending_v0, mdb_val (key_a), value)); - release_assert (status2 == 0 || status2 == MDB_NOTFOUND); - if (status2 == 0) - { - epoch = rai::epoch::epoch_0; - } - else - { - result = true; - } - } - if (!result) - { - rai::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); - pending_a.epoch = epoch; - pending_a.deserialize (stream); - } - return result; -} - -rai::store_iterator rai::mdb_store::pending_begin (rai::transaction const & transaction_a, rai::pending_key const & key_a) -{ - rai::store_iterator result (std::make_unique> (transaction_a, pending_v0, pending_v1, mdb_val (key_a))); - return result; -} - -rai::store_iterator rai::mdb_store::pending_begin (rai::transaction const & transaction_a) -{ - rai::store_iterator result (std::make_unique> (transaction_a, pending_v0, pending_v1)); - return result; -} - -rai::store_iterator rai::mdb_store::pending_end () -{ - rai::store_iterator result (nullptr); - return result; -} - -rai::store_iterator rai::mdb_store::pending_v0_begin (rai::transaction const & transaction_a, rai::pending_key const & key_a) -{ - rai::store_iterator result (std::make_unique> (transaction_a, pending_v0, mdb_val (key_a))); - return result; -} - -rai::store_iterator rai::mdb_store::pending_v0_begin (rai::transaction const & transaction_a) -{ - rai::store_iterator result (std::make_unique> (transaction_a, pending_v0)); - return result; -} - -rai::store_iterator rai::mdb_store::pending_v0_end () -{ - rai::store_iterator result (nullptr); - return result; -} - -rai::store_iterator rai::mdb_store::pending_v1_begin (rai::transaction const & transaction_a, rai::pending_key const & key_a) -{ - rai::store_iterator result (std::make_unique> (transaction_a, pending_v1, mdb_val (key_a))); - return result; -} - -rai::store_iterator rai::mdb_store::pending_v1_begin (rai::transaction const & transaction_a) -{ - rai::store_iterator result (std::make_unique> (transaction_a, pending_v1)); - return result; -} - -rai::store_iterator rai::mdb_store::pending_v1_end () -{ - rai::store_iterator result (nullptr); - return result; -} - -void rai::mdb_store::block_info_put (rai::transaction const & transaction_a, rai::block_hash const & hash_a, rai::block_info const & block_info_a) -{ - auto status (mdb_put (env.tx (transaction_a), blocks_info, rai::mdb_val (hash_a), rai::mdb_val (block_info_a), 0)); - release_assert (status == 0); -} - -void rai::mdb_store::block_info_del (rai::transaction const & transaction_a, rai::block_hash const & hash_a) -{ - auto status (mdb_del (env.tx (transaction_a), blocks_info, rai::mdb_val (hash_a), nullptr)); - release_assert (status == 0); -} - -bool rai::mdb_store::block_info_exists (rai::transaction const & transaction_a, rai::block_hash const & hash_a) -{ - auto iterator (block_info_begin (transaction_a, hash_a)); - return iterator != block_info_end () && rai::block_hash (iterator->first) == hash_a; -} - -bool rai::mdb_store::block_info_get (rai::transaction const & transaction_a, rai::block_hash const & hash_a, rai::block_info & block_info_a) -{ - rai::mdb_val value; - auto status (mdb_get (env.tx (transaction_a), blocks_info, rai::mdb_val (hash_a), value)); - release_assert (status == 0 || status == MDB_NOTFOUND); - bool result (true); - if (status != MDB_NOTFOUND) - { - result = false; - assert (value.size () == sizeof (block_info_a.account.bytes) + sizeof (block_info_a.balance.bytes)); - rai::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); - auto error1 (rai::read (stream, block_info_a.account)); - assert (!error1); - auto error2 (rai::read (stream, block_info_a.balance)); - assert (!error2); - } - return result; -} - -rai::uint128_t rai::mdb_store::representation_get (rai::transaction const & transaction_a, rai::account const & account_a) -{ - rai::mdb_val value; - auto status (mdb_get (env.tx (transaction_a), representation, rai::mdb_val (account_a), value)); - release_assert (status == 0 || status == MDB_NOTFOUND); - rai::uint128_t result = 0; - if (status == 0) - { - rai::uint128_union rep; - rai::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); - auto error (rai::read (stream, rep)); - assert (!error); - result = rep.number (); - } - return result; -} - -void rai::mdb_store::representation_put (rai::transaction const & transaction_a, rai::account const & account_a, rai::uint128_t const & representation_a) -{ - rai::uint128_union rep (representation_a); - auto status (mdb_put (env.tx (transaction_a), representation, rai::mdb_val (account_a), rai::mdb_val (rep), 0)); - release_assert (status == 0); -} - -void rai::mdb_store::unchecked_clear (rai::transaction const & transaction_a) -{ - auto status (mdb_drop (env.tx (transaction_a), unchecked, 0)); - release_assert (status == 0); -} - -void rai::mdb_store::unchecked_put (rai::transaction const & transaction_a, rai::unchecked_key const & key_a, std::shared_ptr const & block_a) -{ - mdb_val block (block_a); - auto status (mdb_put (env.tx (transaction_a), unchecked, rai::mdb_val (key_a), block, 0)); - release_assert (status == 0); -} - -void rai::mdb_store::unchecked_put (rai::transaction const & transaction_a, rai::block_hash const & hash_a, std::shared_ptr const & block_a) -{ - rai::unchecked_key key (hash_a, block_a->hash ()); - unchecked_put (transaction_a, key, block_a); -} - -std::shared_ptr rai::mdb_store::vote_get (rai::transaction const & transaction_a, rai::account const & account_a) -{ - rai::mdb_val value; - auto status (mdb_get (env.tx (transaction_a), vote, rai::mdb_val (account_a), value)); - release_assert (status == 0 || status == MDB_NOTFOUND); - if (status == 0) - { - std::shared_ptr result (value); - assert (result != nullptr); - return result; - } - return nullptr; -} - -std::vector> rai::mdb_store::unchecked_get (rai::transaction const & transaction_a, rai::block_hash const & hash_a) -{ - std::vector> result; - for (auto i (unchecked_begin (transaction_a, rai::unchecked_key (hash_a, 0))), n (unchecked_end ()); i != n && rai::block_hash (i->first.key ()) == hash_a; ++i) - { - std::shared_ptr block (i->second); - result.push_back (block); - } - return result; -} - -bool rai::mdb_store::unchecked_exists (rai::transaction const & transaction_a, rai::unchecked_key const & key_a) -{ - auto iterator (unchecked_begin (transaction_a, key_a)); - return iterator != unchecked_end () && rai::unchecked_key (iterator->first) == key_a; -} - -void rai::mdb_store::unchecked_del (rai::transaction const & transaction_a, rai::unchecked_key const & key_a) -{ - auto status (mdb_del (env.tx (transaction_a), unchecked, rai::mdb_val (key_a), nullptr)); - release_assert (status == 0 || status == MDB_NOTFOUND); -} - -size_t rai::mdb_store::unchecked_count (rai::transaction const & transaction_a) -{ - MDB_stat unchecked_stats; - auto status (mdb_stat (env.tx (transaction_a), unchecked, &unchecked_stats)); - release_assert (status == 0); - auto result (unchecked_stats.ms_entries); - return result; -} - -void rai::mdb_store::checksum_put (rai::transaction const & transaction_a, uint64_t prefix, uint8_t mask, rai::uint256_union const & hash_a) -{ - assert ((prefix & 0xff) == 0); - uint64_t key (prefix | mask); - auto status (mdb_put (env.tx (transaction_a), checksum, rai::mdb_val (sizeof (key), &key), rai::mdb_val (hash_a), 0)); - release_assert (status == 0); -} - -bool rai::mdb_store::checksum_get (rai::transaction const & transaction_a, uint64_t prefix, uint8_t mask, rai::uint256_union & hash_a) -{ - assert ((prefix & 0xff) == 0); - uint64_t key (prefix | mask); - rai::mdb_val value; - auto status (mdb_get (env.tx (transaction_a), checksum, rai::mdb_val (sizeof (key), &key), value)); - release_assert (status == 0 || status == MDB_NOTFOUND); - bool result (true); - if (status == 0) - { - result = false; - rai::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); - auto error (rai::read (stream, hash_a)); - assert (!error); - } - return result; -} - -void rai::mdb_store::checksum_del (rai::transaction const & transaction_a, uint64_t prefix, uint8_t mask) -{ - assert ((prefix & 0xff) == 0); - uint64_t key (prefix | mask); - auto status (mdb_del (env.tx (transaction_a), checksum, rai::mdb_val (sizeof (key), &key), nullptr)); - release_assert (status == 0); -} - -void rai::mdb_store::flush (rai::transaction const & transaction_a) -{ - { - std::lock_guard lock (cache_mutex); - vote_cache_l1.swap (vote_cache_l2); - vote_cache_l1.clear (); - } - for (auto i (vote_cache_l2.begin ()), n (vote_cache_l2.end ()); i != n; ++i) - { - std::vector vector; - { - rai::vectorstream stream (vector); - i->second->serialize (stream); - } - auto status1 (mdb_put (env.tx (transaction_a), vote, rai::mdb_val (i->first), rai::mdb_val (vector.size (), vector.data ()), 0)); - release_assert (status1 == 0); - } -} -std::shared_ptr rai::mdb_store::vote_current (rai::transaction const & transaction_a, rai::account const & account_a) -{ - assert (!cache_mutex.try_lock ()); - std::shared_ptr result; - auto existing (vote_cache_l1.find (account_a)); - auto have_existing (true); - if (existing == vote_cache_l1.end ()) - { - existing = vote_cache_l2.find (account_a); - if (existing == vote_cache_l2.end ()) - { - have_existing = false; - } - } - if (have_existing) - { - result = existing->second; - } - else - { - result = vote_get (transaction_a, account_a); - } - return result; -} - -std::shared_ptr rai::mdb_store::vote_generate (rai::transaction const & transaction_a, rai::account const & account_a, rai::raw_key const & key_a, std::shared_ptr block_a) -{ - std::lock_guard lock (cache_mutex); - auto result (vote_current (transaction_a, account_a)); - uint64_t sequence ((result ? result->sequence : 0) + 1); - result = std::make_shared (account_a, key_a, sequence, block_a); - vote_cache_l1[account_a] = result; - return result; -} - -std::shared_ptr rai::mdb_store::vote_generate (rai::transaction const & transaction_a, rai::account const & account_a, rai::raw_key const & key_a, std::vector blocks_a) -{ - std::lock_guard lock (cache_mutex); - auto result (vote_current (transaction_a, account_a)); - uint64_t sequence ((result ? result->sequence : 0) + 1); - result = std::make_shared (account_a, key_a, sequence, blocks_a); - vote_cache_l1[account_a] = result; - return result; -} - -std::shared_ptr rai::mdb_store::vote_max (rai::transaction const & transaction_a, std::shared_ptr vote_a) -{ - std::lock_guard lock (cache_mutex); - auto current (vote_current (transaction_a, vote_a->account)); - auto result (vote_a); - if (current != nullptr && current->sequence > result->sequence) - { - result = current; - } - vote_cache_l1[vote_a->account] = result; - return result; -} - -rai::store_iterator rai::mdb_store::latest_begin (rai::transaction const & transaction_a, rai::account const & account_a) -{ - rai::store_iterator result (std::make_unique> (transaction_a, accounts_v0, accounts_v1, rai::mdb_val (account_a))); - return result; -} - -rai::store_iterator rai::mdb_store::latest_begin (rai::transaction const & transaction_a) -{ - rai::store_iterator result (std::make_unique> (transaction_a, accounts_v0, accounts_v1)); - return result; -} - -rai::store_iterator rai::mdb_store::latest_end () -{ - rai::store_iterator result (nullptr); - return result; -} - -rai::store_iterator rai::mdb_store::latest_v0_begin (rai::transaction const & transaction_a, rai::account const & account_a) -{ - rai::store_iterator result (std::make_unique> (transaction_a, accounts_v0, rai::mdb_val (account_a))); - return result; -} - -rai::store_iterator rai::mdb_store::latest_v0_begin (rai::transaction const & transaction_a) -{ - rai::store_iterator result (std::make_unique> (transaction_a, accounts_v0)); - return result; -} - -rai::store_iterator rai::mdb_store::latest_v0_end () -{ - rai::store_iterator result (nullptr); - return result; -} - -rai::store_iterator rai::mdb_store::latest_v1_begin (rai::transaction const & transaction_a, rai::account const & account_a) -{ - rai::store_iterator result (std::make_unique> (transaction_a, accounts_v1, rai::mdb_val (account_a))); - return result; -} - -rai::store_iterator rai::mdb_store::latest_v1_begin (rai::transaction const & transaction_a) -{ - rai::store_iterator result (std::make_unique> (transaction_a, accounts_v1)); - return result; -} - -rai::store_iterator rai::mdb_store::latest_v1_end () -{ - rai::store_iterator result (nullptr); - return result; -} diff --git a/rai/node/lmdb.hpp b/rai/node/lmdb.hpp deleted file mode 100644 index a1f2798a..00000000 --- a/rai/node/lmdb.hpp +++ /dev/null @@ -1,389 +0,0 @@ -#pragma once - -#include - -#include - -#include -#include -#include - -namespace rai -{ -class mdb_env; -class mdb_txn : public transaction_impl -{ -public: - mdb_txn (rai::mdb_env const &, bool = false); - mdb_txn (rai::mdb_txn const &) = delete; - mdb_txn (rai::mdb_txn &&) = default; - ~mdb_txn (); - rai::mdb_txn & operator= (rai::mdb_txn const &) = delete; - rai::mdb_txn & operator= (rai::mdb_txn &&) = default; - operator MDB_txn * () const; - MDB_txn * handle; -}; -/** - * RAII wrapper for MDB_env - */ -class mdb_env -{ -public: - mdb_env (bool &, boost::filesystem::path const &, int max_dbs = 128); - ~mdb_env (); - operator MDB_env * () const; - rai::transaction tx_begin (bool = false) const; - MDB_txn * tx (rai::transaction const &) const; - MDB_env * environment; -}; - -/** - * Encapsulates MDB_val and provides uint256_union conversion of the data. - */ -class mdb_val -{ -public: - enum class no_value - { - dummy - }; - mdb_val (rai::epoch = rai::epoch::unspecified); - mdb_val (rai::account_info const &); - mdb_val (rai::block_info const &); - mdb_val (MDB_val const &, rai::epoch = rai::epoch::unspecified); - mdb_val (rai::pending_info const &); - mdb_val (rai::pending_key const &); - mdb_val (size_t, void *); - mdb_val (rai::uint128_union const &); - mdb_val (rai::uint256_union const &); - mdb_val (std::shared_ptr const &); - mdb_val (std::shared_ptr const &); - void * data () const; - size_t size () const; - explicit operator rai::account_info () const; - explicit operator rai::block_info () const; - explicit operator rai::pending_info () const; - explicit operator rai::pending_key () const; - explicit operator rai::uint128_union () const; - explicit operator rai::uint256_union () const; - explicit operator std::array () const; - explicit operator no_value () const; - explicit operator std::shared_ptr () const; - explicit operator std::shared_ptr () const; - explicit operator std::shared_ptr () const; - explicit operator std::shared_ptr () const; - explicit operator std::shared_ptr () const; - explicit operator std::shared_ptr () const; - explicit operator std::shared_ptr () const; - explicit operator uint64_t () const; - operator MDB_val * () const; - operator MDB_val const & () const; - MDB_val value; - std::shared_ptr> buffer; - rai::epoch epoch{ rai::epoch::unspecified }; -}; -class block_store; - -template -class mdb_iterator : public store_iterator_impl -{ -public: - mdb_iterator (rai::transaction const & transaction_a, MDB_dbi db_a, rai::epoch = rai::epoch::unspecified); - mdb_iterator (std::nullptr_t, rai::epoch = rai::epoch::unspecified); - mdb_iterator (rai::transaction const & transaction_a, MDB_dbi db_a, MDB_val const & val_a, rai::epoch = rai::epoch::unspecified); - mdb_iterator (rai::mdb_iterator && other_a); - mdb_iterator (rai::mdb_iterator const &) = delete; - ~mdb_iterator (); - rai::store_iterator_impl & operator++ () override; - std::pair * operator-> (); - bool operator== (rai::store_iterator_impl const & other_a) const override; - bool is_end_sentinal () const override; - void fill (std::pair &) const override; - void clear (); - rai::mdb_iterator & operator= (rai::mdb_iterator && other_a); - rai::store_iterator_impl & operator= (rai::store_iterator_impl const &) = delete; - MDB_cursor * cursor; - std::pair current; - -private: - MDB_txn * tx (rai::transaction const &) const; -}; - -/** - * Iterates the key/value pairs of two stores merged together - */ -template -class mdb_merge_iterator : public store_iterator_impl -{ -public: - mdb_merge_iterator (rai::transaction const &, MDB_dbi, MDB_dbi); - mdb_merge_iterator (std::nullptr_t); - mdb_merge_iterator (rai::transaction const &, MDB_dbi, MDB_dbi, MDB_val const &); - mdb_merge_iterator (rai::mdb_merge_iterator &&); - mdb_merge_iterator (rai::mdb_merge_iterator const &) = delete; - ~mdb_merge_iterator (); - rai::store_iterator_impl & operator++ () override; - std::pair * operator-> (); - bool operator== (rai::store_iterator_impl const &) const override; - bool is_end_sentinal () const override; - void fill (std::pair &) const override; - void clear (); - rai::mdb_merge_iterator & operator= (rai::mdb_merge_iterator &&) = default; - rai::mdb_merge_iterator & operator= (rai::mdb_merge_iterator const &) = delete; - -private: - rai::mdb_iterator & least_iterator () const; - std::unique_ptr> impl1; - std::unique_ptr> impl2; -}; - -/** - * mdb implementation of the block store - */ -class mdb_store : public block_store -{ - friend class rai::block_predecessor_set; - -public: - mdb_store (bool &, boost::filesystem::path const &, int lmdb_max_dbs = 128); - - rai::transaction tx_begin_write () override; - rai::transaction tx_begin_read () override; - rai::transaction tx_begin (bool write = false) override; - - void initialize (rai::transaction const &, rai::genesis const &) override; - void block_put (rai::transaction const &, rai::block_hash const &, rai::block const &, rai::block_hash const & = rai::block_hash (0), rai::epoch version = rai::epoch::epoch_0) override; - rai::block_hash block_successor (rai::transaction const &, rai::block_hash const &) override; - void block_successor_clear (rai::transaction const &, rai::block_hash const &) override; - std::shared_ptr block_get (rai::transaction const &, rai::block_hash const &) override; - std::shared_ptr block_random (rai::transaction const &) override; - void block_del (rai::transaction const &, rai::block_hash const &) override; - bool block_exists (rai::transaction const &, rai::block_hash const &) override; - bool block_exists (rai::transaction const &, rai::block_type, rai::block_hash const &) override; - rai::block_counts block_count (rai::transaction const &) override; - bool root_exists (rai::transaction const &, rai::uint256_union const &) override; - - void frontier_put (rai::transaction const &, rai::block_hash const &, rai::account const &) override; - rai::account frontier_get (rai::transaction const &, rai::block_hash const &) override; - void frontier_del (rai::transaction const &, rai::block_hash const &) override; - - void account_put (rai::transaction const &, rai::account const &, rai::account_info const &) override; - bool account_get (rai::transaction const &, rai::account const &, rai::account_info &) override; - void account_del (rai::transaction const &, rai::account const &) override; - bool account_exists (rai::transaction const &, rai::account const &) override; - size_t account_count (rai::transaction const &) override; - rai::store_iterator latest_v0_begin (rai::transaction const &, rai::account const &) override; - rai::store_iterator latest_v0_begin (rai::transaction const &) override; - rai::store_iterator latest_v0_end () override; - rai::store_iterator latest_v1_begin (rai::transaction const &, rai::account const &) override; - rai::store_iterator latest_v1_begin (rai::transaction const &) override; - rai::store_iterator latest_v1_end () override; - rai::store_iterator latest_begin (rai::transaction const &, rai::account const &) override; - rai::store_iterator latest_begin (rai::transaction const &) override; - rai::store_iterator latest_end () override; - - void pending_put (rai::transaction const &, rai::pending_key const &, rai::pending_info const &) override; - void pending_del (rai::transaction const &, rai::pending_key const &) override; - bool pending_get (rai::transaction const &, rai::pending_key const &, rai::pending_info &) override; - bool pending_exists (rai::transaction const &, rai::pending_key const &) override; - rai::store_iterator pending_v0_begin (rai::transaction const &, rai::pending_key const &) override; - rai::store_iterator pending_v0_begin (rai::transaction const &) override; - rai::store_iterator pending_v0_end () override; - rai::store_iterator pending_v1_begin (rai::transaction const &, rai::pending_key const &) override; - rai::store_iterator pending_v1_begin (rai::transaction const &) override; - rai::store_iterator pending_v1_end () override; - rai::store_iterator pending_begin (rai::transaction const &, rai::pending_key const &) override; - rai::store_iterator pending_begin (rai::transaction const &) override; - rai::store_iterator pending_end () override; - - void block_info_put (rai::transaction const &, rai::block_hash const &, rai::block_info const &) override; - void block_info_del (rai::transaction const &, rai::block_hash const &) override; - bool block_info_get (rai::transaction const &, rai::block_hash const &, rai::block_info &) override; - bool block_info_exists (rai::transaction const &, rai::block_hash const &) override; - rai::store_iterator block_info_begin (rai::transaction const &, rai::block_hash const &) override; - rai::store_iterator block_info_begin (rai::transaction const &) override; - rai::store_iterator block_info_end () override; - rai::uint128_t block_balance (rai::transaction const &, rai::block_hash const &) override; - rai::epoch block_version (rai::transaction const &, rai::block_hash const &) override; - - rai::uint128_t representation_get (rai::transaction const &, rai::account const &) override; - void representation_put (rai::transaction const &, rai::account const &, rai::uint128_t const &) override; - void representation_add (rai::transaction const &, rai::account const &, rai::uint128_t const &) override; - rai::store_iterator representation_begin (rai::transaction const &) override; - rai::store_iterator representation_end () override; - - void unchecked_clear (rai::transaction const &) override; - void unchecked_put (rai::transaction const &, rai::unchecked_key const &, std::shared_ptr const &) override; - void unchecked_put (rai::transaction const &, rai::block_hash const &, std::shared_ptr const &) override; - std::vector> unchecked_get (rai::transaction const &, rai::block_hash const &) override; - bool unchecked_exists (rai::transaction const &, rai::unchecked_key const &) override; - void unchecked_del (rai::transaction const &, rai::unchecked_key const &) override; - rai::store_iterator> unchecked_begin (rai::transaction const &) override; - rai::store_iterator> unchecked_begin (rai::transaction const &, rai::unchecked_key const &) override; - rai::store_iterator> unchecked_end () override; - size_t unchecked_count (rai::transaction const &) override; - - void checksum_put (rai::transaction const &, uint64_t, uint8_t, rai::checksum const &) override; - bool checksum_get (rai::transaction const &, uint64_t, uint8_t, rai::checksum &) override; - void checksum_del (rai::transaction const &, uint64_t, uint8_t) override; - - // Return latest vote for an account from store - std::shared_ptr vote_get (rai::transaction const &, rai::account const &) override; - // Populate vote with the next sequence number - std::shared_ptr vote_generate (rai::transaction const &, rai::account const &, rai::raw_key const &, std::shared_ptr) override; - std::shared_ptr vote_generate (rai::transaction const &, rai::account const &, rai::raw_key const &, std::vector) override; - // Return either vote or the stored vote with a higher sequence number - std::shared_ptr vote_max (rai::transaction const &, std::shared_ptr) override; - // Return latest vote for an account considering the vote cache - std::shared_ptr vote_current (rai::transaction const &, rai::account const &) override; - void flush (rai::transaction const &) override; - rai::store_iterator> vote_begin (rai::transaction const &) override; - rai::store_iterator> vote_end () override; - std::mutex cache_mutex; - std::unordered_map> vote_cache_l1; - std::unordered_map> vote_cache_l2; - - void version_put (rai::transaction const &, int) override; - int version_get (rai::transaction const &) override; - void do_upgrades (rai::transaction const &); - void upgrade_v1_to_v2 (rai::transaction const &); - void upgrade_v2_to_v3 (rai::transaction const &); - void upgrade_v3_to_v4 (rai::transaction const &); - void upgrade_v4_to_v5 (rai::transaction const &); - void upgrade_v5_to_v6 (rai::transaction const &); - void upgrade_v6_to_v7 (rai::transaction const &); - void upgrade_v7_to_v8 (rai::transaction const &); - void upgrade_v8_to_v9 (rai::transaction const &); - void upgrade_v9_to_v10 (rai::transaction const &); - void upgrade_v10_to_v11 (rai::transaction const &); - void upgrade_v11_to_v12 (rai::transaction const &); - - // Requires a write transaction - rai::raw_key get_node_id (rai::transaction const &) override; - - /** Deletes the node ID from the store */ - void delete_node_id (rai::transaction const &) override; - - rai::mdb_env env; - - /** - * Maps head block to owning account - * rai::block_hash -> rai::account - */ - MDB_dbi frontiers; - - /** - * Maps account v1 to account information, head, rep, open, balance, timestamp and block count. - * rai::account -> rai::block_hash, rai::block_hash, rai::block_hash, rai::amount, uint64_t, uint64_t - */ - MDB_dbi accounts_v0; - - /** - * Maps account v0 to account information, head, rep, open, balance, timestamp and block count. - * rai::account -> rai::block_hash, rai::block_hash, rai::block_hash, rai::amount, uint64_t, uint64_t - */ - MDB_dbi accounts_v1; - - /** - * Maps block hash to send block. - * rai::block_hash -> rai::send_block - */ - MDB_dbi send_blocks; - - /** - * Maps block hash to receive block. - * rai::block_hash -> rai::receive_block - */ - MDB_dbi receive_blocks; - - /** - * Maps block hash to open block. - * rai::block_hash -> rai::open_block - */ - MDB_dbi open_blocks; - - /** - * Maps block hash to change block. - * rai::block_hash -> rai::change_block - */ - MDB_dbi change_blocks; - - /** - * Maps block hash to v0 state block. - * rai::block_hash -> rai::state_block - */ - MDB_dbi state_blocks_v0; - - /** - * Maps block hash to v1 state block. - * rai::block_hash -> rai::state_block - */ - MDB_dbi state_blocks_v1; - - /** - * Maps min_version 0 (destination account, pending block) to (source account, amount). - * rai::account, rai::block_hash -> rai::account, rai::amount - */ - MDB_dbi pending_v0; - - /** - * Maps min_version 1 (destination account, pending block) to (source account, amount). - * rai::account, rai::block_hash -> rai::account, rai::amount - */ - MDB_dbi pending_v1; - - /** - * Maps block hash to account and balance. - * block_hash -> rai::account, rai::amount - */ - MDB_dbi blocks_info; - - /** - * Representative weights. - * rai::account -> rai::uint128_t - */ - MDB_dbi representation; - - /** - * Unchecked bootstrap blocks. - * rai::block_hash -> rai::block - */ - MDB_dbi unchecked; - - /** - * Mapping of region to checksum. - * (uint56_t, uint8_t) -> rai::block_hash - */ - MDB_dbi checksum; - - /** - * Highest vote observed for account. - * rai::account -> uint64_t - */ - MDB_dbi vote; - - /** - * Meta information about block store, such as versions. - * rai::uint256_union (arbitrary key) -> blob - */ - MDB_dbi meta; - -private: - MDB_dbi block_database (rai::block_type, rai::epoch); - template - std::shared_ptr block_random (rai::transaction const &, MDB_dbi); - MDB_val block_raw_get (rai::transaction const &, rai::block_hash const &, rai::block_type &); - void block_raw_put (rai::transaction const &, MDB_dbi, rai::block_hash const &, MDB_val); - void clear (MDB_dbi); -}; -class wallet_value -{ -public: - wallet_value () = default; - wallet_value (rai::mdb_val const &); - wallet_value (rai::uint256_union const &, uint64_t); - rai::mdb_val val () const; - rai::private_key key; - uint64_t work; -}; -} diff --git a/rai/node/node.hpp b/rai/node/node.hpp deleted file mode 100644 index 924846a4..00000000 --- a/rai/node/node.hpp +++ /dev/null @@ -1,553 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include -#include -#include -#include -#include -#include - -#include - -#include -#include -#include -#include -#include -#include -#include - -namespace rai -{ -class node; -class election_status -{ -public: - std::shared_ptr winner; - rai::amount tally; - std::chrono::milliseconds election_end; - std::chrono::milliseconds election_duration; -}; -class vote_info -{ -public: - std::chrono::steady_clock::time_point time; - uint64_t sequence; - rai::block_hash hash; -}; -class election_vote_result -{ -public: - election_vote_result (); - election_vote_result (bool, bool); - bool replay; - bool processed; -}; -class election : public std::enable_shared_from_this -{ - std::function)> confirmation_action; - void confirm_once (rai::transaction const &); - void confirm_back (rai::transaction const &); - -public: - election (rai::node &, std::shared_ptr, std::function)> const &); - rai::election_vote_result vote (rai::account, uint64_t, rai::block_hash); - rai::tally_t tally (rai::transaction const &); - // Check if we have vote quorum - bool have_quorum (rai::tally_t const &, rai::uint128_t); - // Change our winner to agree with the network - void compute_rep_votes (rai::transaction const &); - // Confirm this block if quorum is met - void confirm_if_quorum (rai::transaction const &); - void log_votes (rai::tally_t const &); - bool publish (std::shared_ptr block_a); - void stop (); - rai::node & node; - std::unordered_map last_votes; - std::unordered_map> blocks; - rai::block_hash root; - std::chrono::steady_clock::time_point election_start; - rai::election_status status; - std::atomic confirmed; - bool stopped; - std::unordered_map last_tally; - unsigned announcements; -}; -class conflict_info -{ -public: - rai::block_hash root; - uint64_t difficulty; - std::shared_ptr election; -}; -// Core class for determining consensus -// Holds all active blocks i.e. recently added blocks that need confirmation -class active_transactions -{ -public: - active_transactions (rai::node &); - ~active_transactions (); - // Start an election for a block - // Call action with confirmed block, may be different than what we started with - bool start (std::shared_ptr, std::function)> const & = [](std::shared_ptr) {}); - // If this returns true, the vote is a replay - // If this returns false, the vote may or may not be a replay - bool vote (std::shared_ptr, bool = false); - // Is the root of this block in the roots container - bool active (rai::block const &); - void update_difficulty (rai::block const &); - std::deque> list_blocks (bool = false); - void erase (rai::block const &); - void stop (); - bool publish (std::shared_ptr block_a); - boost::multi_index_container< - rai::conflict_info, - boost::multi_index::indexed_by< - boost::multi_index::hashed_unique< - boost::multi_index::member>, - boost::multi_index::ordered_non_unique< - boost::multi_index::member, - std::greater>>> - roots; - std::unordered_map> blocks; - std::deque confirmed; - rai::node & node; - std::mutex mutex; - // Maximum number of conflicts to vote on per interval, lowest root hash first - static unsigned constexpr announcements_per_interval = 32; - // Minimum number of block announcements - static unsigned constexpr announcement_min = 2; - // Threshold to start logging blocks haven't yet been confirmed - static unsigned constexpr announcement_long = 20; - static unsigned constexpr announce_interval_ms = (rai::rai_network == rai::rai_networks::rai_test_network) ? 10 : 16000; - static size_t constexpr election_history_size = 2048; - static size_t constexpr max_broadcast_queue = 1000; - -private: - // Call action with confirmed block, may be different than what we started with - bool add (std::shared_ptr, std::function)> const & = [](std::shared_ptr) {}); - void announce_loop (); - void announce_votes (std::unique_lock &); - std::condition_variable condition; - bool started; - bool stopped; - boost::thread thread; -}; -class operation -{ -public: - bool operator> (rai::operation const &) const; - std::chrono::steady_clock::time_point wakeup; - std::function function; -}; -class alarm -{ -public: - alarm (boost::asio::io_context &); - ~alarm (); - void add (std::chrono::steady_clock::time_point const &, std::function const &); - void run (); - boost::asio::io_context & io_ctx; - std::mutex mutex; - std::condition_variable condition; - std::priority_queue, std::greater> operations; - boost::thread thread; -}; -class gap_information -{ -public: - std::chrono::steady_clock::time_point arrival; - rai::block_hash hash; - std::unordered_set voters; -}; -class gap_cache -{ -public: - gap_cache (rai::node &); - void add (rai::transaction const &, std::shared_ptr); - void vote (std::shared_ptr); - rai::uint128_t bootstrap_threshold (rai::transaction const &); - boost::multi_index_container< - rai::gap_information, - boost::multi_index::indexed_by< - boost::multi_index::ordered_non_unique>, - boost::multi_index::hashed_unique>>> - blocks; - size_t const max = 256; - std::mutex mutex; - rai::node & node; -}; -class work_pool; -class send_info -{ -public: - uint8_t const * data; - size_t size; - rai::endpoint endpoint; - std::function callback; -}; -class block_arrival_info -{ -public: - std::chrono::steady_clock::time_point arrival; - rai::block_hash hash; -}; -// This class tracks blocks that are probably live because they arrived in a UDP packet -// This gives a fairly reliable way to differentiate between blocks being inserted via bootstrap or new, live blocks. -class block_arrival -{ -public: - // Return `true' to indicated an error if the block has already been inserted - bool add (rai::block_hash const &); - bool recent (rai::block_hash const &); - boost::multi_index_container< - rai::block_arrival_info, - boost::multi_index::indexed_by< - boost::multi_index::ordered_non_unique>, - boost::multi_index::hashed_unique>>> - arrival; - std::mutex mutex; - static size_t constexpr arrival_size_min = 8 * 1024; - static std::chrono::seconds constexpr arrival_time_min = std::chrono::seconds (300); -}; -class rep_last_heard_info -{ -public: - std::chrono::steady_clock::time_point last_heard; - rai::account representative; -}; -class online_reps -{ -public: - online_reps (rai::node &); - void vote (std::shared_ptr const &); - void recalculate_stake (); - rai::uint128_t online_stake (); - rai::uint128_t online_stake_total; - std::vector list (); - boost::multi_index_container< - rai::rep_last_heard_info, - boost::multi_index::indexed_by< - boost::multi_index::ordered_non_unique>, - boost::multi_index::hashed_unique>>> - reps; - -private: - std::mutex mutex; - rai::node & node; -}; -class udp_data -{ -public: - uint8_t * buffer; - size_t size; - rai::endpoint endpoint; -}; -/** - * A circular buffer for servicing UDP datagrams. This container follows a producer/consumer model where the operating system is producing data in to buffers which are serviced by internal threads. - * If buffers are not serviced fast enough they're internally dropped. - * This container has a maximum space to hold N buffers of M size and will allocate them in round-robin order. - * All public methods are thread-safe -*/ -class udp_buffer -{ -public: - // Stats - Statistics - // Size - Size of each individual buffer - // Count - Number of buffers to allocate - udp_buffer (rai::stat & stats, size_t, size_t); - // Return a buffer where UDP data can be put - // Method will attempt to return the first free buffer - // If there are no free buffers, an unserviced buffer will be dequeued and returned - // Function will block if there are no free or unserviced buffers - // Return nullptr if the container has stopped - rai::udp_data * allocate (); - // Queue a buffer that has been filled with UDP data and notify servicing threads - void enqueue (rai::udp_data *); - // Return a buffer that has been filled with UDP data - // Function will block until a buffer has been added - // Return nullptr if the container has stopped - rai::udp_data * dequeue (); - // Return a buffer to the freelist after is has been serviced - void release (rai::udp_data *); - // Stop container and notify waiting threads - void stop (); - -private: - rai::stat & stats; - std::mutex mutex; - std::condition_variable condition; - boost::circular_buffer free; - boost::circular_buffer full; - std::vector slab; - std::vector entries; - bool stopped; -}; -class network -{ -public: - network (rai::node &, uint16_t); - ~network (); - void receive (); - void process_packets (); - void start (); - void stop (); - void receive_action (rai::udp_data *); - void rpc_action (boost::system::error_code const &, size_t); - void republish_vote (std::shared_ptr); - void republish_block (std::shared_ptr); - static unsigned const broadcast_interval_ms = 10; - void republish_block_batch (std::deque>, unsigned = broadcast_interval_ms); - void republish (rai::block_hash const &, std::shared_ptr>, rai::endpoint); - void confirm_send (rai::confirm_ack const &, std::shared_ptr>, rai::endpoint const &); - void merge_peers (std::array const &); - void send_keepalive (rai::endpoint const &); - void send_node_id_handshake (rai::endpoint const &, boost::optional const & query, boost::optional const & respond_to); - void broadcast_confirm_req (std::shared_ptr); - void broadcast_confirm_req_base (std::shared_ptr, std::shared_ptr>, unsigned, bool = false); - void broadcast_confirm_req_batch (std::deque, std::shared_ptr>>>, unsigned = broadcast_interval_ms); - void send_confirm_req (rai::endpoint const &, std::shared_ptr); - void send_buffer (uint8_t const *, size_t, rai::endpoint const &, std::function); - rai::endpoint endpoint (); - rai::udp_buffer buffer_container; - boost::asio::ip::udp::socket socket; - std::mutex socket_mutex; - boost::asio::ip::udp::resolver resolver; - std::vector packet_processing_threads; - rai::node & node; - bool on; - static uint16_t const node_port = rai::rai_network == rai::rai_networks::rai_live_network ? 7075 : 54000; - static size_t const buffer_size = 512; -}; - -class node_init -{ -public: - node_init (); - bool error (); - bool block_store_init; - bool wallet_init; -}; -class node_observers -{ -public: - rai::observer_set, rai::account const &, rai::uint128_t const &, bool> blocks; - rai::observer_set wallet; - rai::observer_set, rai::endpoint const &> vote; - rai::observer_set account_balance; - rai::observer_set endpoint; - rai::observer_set<> disconnect; -}; -class vote_processor -{ -public: - vote_processor (rai::node &); - void vote (std::shared_ptr, rai::endpoint); - // node.active.mutex lock required - rai::vote_code vote_blocking (rai::transaction const &, std::shared_ptr, rai::endpoint, bool = false); - void verify_votes (std::deque, rai::endpoint>> &); - void flush (); - void calculate_weights (); - rai::node & node; - void stop (); - -private: - void process_loop (); - std::deque, rai::endpoint>> votes; - // Representatives levels for random early detection - std::unordered_set representatives_1; - std::unordered_set representatives_2; - std::unordered_set representatives_3; - std::condition_variable condition; - std::mutex mutex; - bool started; - bool stopped; - bool active; - boost::thread thread; -}; -// The network is crawled for representatives by occasionally sending a unicast confirm_req for a specific block and watching to see if it's acknowledged with a vote. -class rep_crawler -{ -public: - void add (rai::block_hash const &); - void remove (rai::block_hash const &); - bool exists (rai::block_hash const &); - std::mutex mutex; - std::unordered_set active; -}; -class block_processor; -class signature_check_set -{ -public: - size_t size; - unsigned char const ** messages; - size_t * message_lengths; - unsigned char const ** pub_keys; - unsigned char const ** signatures; - int * verifications; - std::promise * promise; -}; -class signature_checker -{ -public: - signature_checker (); - ~signature_checker (); - void add (signature_check_set &); - void stop (); - void flush (); - -private: - void run (); - void verify (rai::signature_check_set & check_a); - std::deque checks; - bool started; - bool stopped; - std::mutex mutex; - std::condition_variable condition; - std::thread thread; -}; -// Processing blocks is a potentially long IO operation -// This class isolates block insertion from other operations like servicing network operations -class block_processor -{ -public: - block_processor (rai::node &); - ~block_processor (); - void stop (); - void flush (); - bool full (); - void add (std::shared_ptr, std::chrono::steady_clock::time_point); - void force (std::shared_ptr); - bool should_log (bool); - bool have_blocks (); - void process_blocks (); - rai::process_return process_receive_one (rai::transaction const &, std::shared_ptr, std::chrono::steady_clock::time_point = std::chrono::steady_clock::now (), bool = false); - -private: - void queue_unchecked (rai::transaction const &, rai::block_hash const &); - void verify_state_blocks (std::unique_lock &, size_t = std::numeric_limits::max ()); - void process_receive_many (std::unique_lock &); - bool stopped; - bool active; - std::chrono::steady_clock::time_point next_log; - std::deque, std::chrono::steady_clock::time_point>> state_blocks; - std::deque, std::chrono::steady_clock::time_point>> blocks; - std::unordered_set blocks_hashes; - std::deque> forced; - std::condition_variable condition; - rai::node & node; - rai::vote_generator generator; - std::mutex mutex; -}; -class node : public std::enable_shared_from_this -{ -public: - node (rai::node_init &, boost::asio::io_context &, uint16_t, boost::filesystem::path const &, rai::alarm &, rai::logging const &, rai::work_pool &); - node (rai::node_init &, boost::asio::io_context &, boost::filesystem::path const &, rai::alarm &, rai::node_config const &, rai::work_pool &); - ~node (); - template - void background (T action_a) - { - alarm.io_ctx.post (action_a); - } - void send_keepalive (rai::endpoint const &); - bool copy_with_compaction (boost::filesystem::path const &); - void keepalive (std::string const &, uint16_t); - void start (); - void stop (); - std::shared_ptr shared (); - int store_version (); - void process_confirmed (std::shared_ptr); - void process_message (rai::message &, rai::endpoint const &); - void process_active (std::shared_ptr); - rai::process_return process (rai::block const &); - void keepalive_preconfigured (std::vector const &); - rai::block_hash latest (rai::account const &); - rai::uint128_t balance (rai::account const &); - std::shared_ptr block (rai::block_hash const &); - std::pair balance_pending (rai::account const &); - rai::uint128_t weight (rai::account const &); - rai::account representative (rai::account const &); - void ongoing_keepalive (); - void ongoing_syn_cookie_cleanup (); - void ongoing_rep_crawl (); - void ongoing_rep_calculation (); - void ongoing_bootstrap (); - void ongoing_store_flush (); - void backup_wallet (); - void search_pending (); - int price (rai::uint128_t const &, int); - void work_generate_blocking (rai::block &, uint64_t = rai::work_pool::publish_threshold); - uint64_t work_generate_blocking (rai::uint256_union const &, uint64_t = rai::work_pool::publish_threshold); - void work_generate (rai::uint256_union const &, std::function, uint64_t = rai::work_pool::publish_threshold); - void add_initial_peers (); - void block_confirm (std::shared_ptr); - void process_fork (rai::transaction const &, std::shared_ptr); - bool validate_block_by_previous (rai::transaction const &, std::shared_ptr); - rai::uint128_t delta (); - boost::asio::io_context & io_ctx; - rai::node_config config; - rai::node_flags flags; - rai::alarm & alarm; - rai::work_pool & work; - boost::log::sources::logger_mt log; - std::unique_ptr store_impl; - rai::block_store & store; - rai::gap_cache gap_cache; - rai::ledger ledger; - rai::active_transactions active; - rai::network network; - rai::bootstrap_initiator bootstrap_initiator; - rai::bootstrap_listener bootstrap; - rai::peer_container peers; - boost::filesystem::path application_path; - rai::node_observers observers; - rai::wallets wallets; - rai::port_mapping port_mapping; - rai::signature_checker checker; - rai::vote_processor vote_processor; - rai::rep_crawler rep_crawler; - unsigned warmed_up; - rai::block_processor block_processor; - boost::thread block_processor_thread; - rai::block_arrival block_arrival; - rai::online_reps online_reps; - rai::stat stats; - rai::keypair node_id; - rai::block_uniquer block_uniquer; - rai::vote_uniquer vote_uniquer; - static double constexpr price_max = 16.0; - static double constexpr free_cutoff = 1024.0; - static std::chrono::seconds constexpr period = std::chrono::seconds (60); - static std::chrono::seconds constexpr cutoff = period * 5; - static std::chrono::seconds constexpr syn_cookie_cutoff = std::chrono::seconds (5); - static std::chrono::minutes constexpr backup_interval = std::chrono::minutes (5); - static std::chrono::seconds constexpr search_pending_interval = (rai::rai_network == rai::rai_networks::rai_test_network) ? std::chrono::seconds (1) : std::chrono::seconds (5 * 60); -}; -class thread_runner -{ -public: - thread_runner (boost::asio::io_context &, unsigned); - ~thread_runner (); - void join (); - std::vector threads; -}; -class inactive_node -{ -public: - inactive_node (boost::filesystem::path const & path = rai::working_path (), uint16_t = 24000); - ~inactive_node (); - boost::filesystem::path path; - std::shared_ptr io_context; - rai::alarm alarm; - rai::logging logging; - rai::node_init init; - rai::work_pool work; - uint16_t peering_port; - std::shared_ptr node; -}; -} diff --git a/rai/node/testing.hpp b/rai/node/testing.hpp deleted file mode 100644 index 42bdc74b..00000000 --- a/rai/node/testing.hpp +++ /dev/null @@ -1,80 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace rai -{ -/** Test-system related error codes */ -enum class error_system -{ - generic = 1, - deadline_expired -}; -class system -{ -public: - system (uint16_t, size_t); - ~system (); - void generate_activity (rai::node &, std::vector &); - void generate_mass_activity (uint32_t, rai::node &); - void generate_usage_traffic (uint32_t, uint32_t, size_t); - void generate_usage_traffic (uint32_t, uint32_t); - rai::account get_random_account (std::vector &); - rai::uint128_t get_random_amount (rai::transaction const &, rai::node &, rai::account const &); - void generate_rollback (rai::node &, std::vector &); - void generate_change_known (rai::node &, std::vector &); - void generate_change_unknown (rai::node &, std::vector &); - void generate_receive (rai::node &); - void generate_send_new (rai::node &, std::vector &); - void generate_send_existing (rai::node &, std::vector &); - std::shared_ptr wallet (size_t); - rai::account account (rai::transaction const &, size_t); - /** - * Polls, sleep if there's no work to be done (default 50ms), then check the deadline - * @returns 0 or rai::deadline_expired - */ - std::error_code poll (const std::chrono::nanoseconds & sleep_time = std::chrono::milliseconds (50)); - void stop (); - void deadline_set (const std::chrono::duration & delta); - boost::asio::io_context io_ctx; - rai::alarm alarm; - std::vector> nodes; - rai::logging logging; - rai::work_pool work; - std::chrono::time_point> deadline{ std::chrono::steady_clock::time_point::max () }; - double deadline_scaling_factor{ 1.0 }; -}; -class landing_store -{ -public: - landing_store (); - landing_store (rai::account const &, rai::account const &, uint64_t, uint64_t); - landing_store (bool &, std::istream &); - rai::account source; - rai::account destination; - uint64_t start; - uint64_t last; - bool deserialize (std::istream &); - void serialize (std::ostream &) const; - bool operator== (rai::landing_store const &) const; -}; -class landing -{ -public: - landing (rai::node &, std::shared_ptr, rai::landing_store &, boost::filesystem::path const &); - void write_store (); - rai::uint128_t distribution_amount (uint64_t); - void distribute_one (); - void distribute_ongoing (); - boost::filesystem::path path; - rai::landing_store & store; - std::shared_ptr wallet; - rai::node & node; - static int constexpr interval_exponent = 10; - static std::chrono::seconds constexpr distribution_interval = std::chrono::seconds (1 << interval_exponent); // 1024 seconds - static std::chrono::seconds constexpr sleep_seconds = std::chrono::seconds (7); -}; -} -REGISTER_ERROR_CODES (rai, error_system); diff --git a/rai/node/wallet.hpp b/rai/node/wallet.hpp deleted file mode 100644 index 7bbae5bf..00000000 --- a/rai/node/wallet.hpp +++ /dev/null @@ -1,208 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include -#include - -#include -#include -#include -#include - -namespace rai -{ -// The fan spreads a key out over the heap to decrease the likelihood of it being recovered by memory inspection -class fan -{ -public: - fan (rai::uint256_union const &, size_t); - void value (rai::raw_key &); - void value_set (rai::raw_key const &); - std::vector> values; - -private: - std::mutex mutex; - void value_get (rai::raw_key &); -}; -class node_config; -class kdf -{ -public: - void phs (rai::raw_key &, std::string const &, rai::uint256_union const &); - std::mutex mutex; -}; -enum class key_type -{ - not_a_type, - unknown, - adhoc, - deterministic -}; -class wallet_store -{ -public: - wallet_store (bool &, rai::kdf &, rai::transaction &, rai::account, unsigned, std::string const &); - wallet_store (bool &, rai::kdf &, rai::transaction &, rai::account, unsigned, std::string const &, std::string const &); - std::vector accounts (rai::transaction const &); - void initialize (rai::transaction const &, bool &, std::string const &); - rai::uint256_union check (rai::transaction const &); - bool rekey (rai::transaction const &, std::string const &); - bool valid_password (rai::transaction const &); - bool attempt_password (rai::transaction const &, std::string const &); - void wallet_key (rai::raw_key &, rai::transaction const &); - void seed (rai::raw_key &, rai::transaction const &); - void seed_set (rai::transaction const &, rai::raw_key const &); - rai::key_type key_type (rai::wallet_value const &); - rai::public_key deterministic_insert (rai::transaction const &); - void deterministic_key (rai::raw_key &, rai::transaction const &, uint32_t); - uint32_t deterministic_index_get (rai::transaction const &); - void deterministic_index_set (rai::transaction const &, uint32_t); - void deterministic_clear (rai::transaction const &); - rai::uint256_union salt (rai::transaction const &); - bool is_representative (rai::transaction const &); - rai::account representative (rai::transaction const &); - void representative_set (rai::transaction const &, rai::account const &); - rai::public_key insert_adhoc (rai::transaction const &, rai::raw_key const &); - void insert_watch (rai::transaction const &, rai::public_key const &); - void erase (rai::transaction const &, rai::public_key const &); - rai::wallet_value entry_get_raw (rai::transaction const &, rai::public_key const &); - void entry_put_raw (rai::transaction const &, rai::public_key const &, rai::wallet_value const &); - bool fetch (rai::transaction const &, rai::public_key const &, rai::raw_key &); - bool exists (rai::transaction const &, rai::public_key const &); - void destroy (rai::transaction const &); - rai::store_iterator find (rai::transaction const &, rai::uint256_union const &); - rai::store_iterator begin (rai::transaction const &, rai::uint256_union const &); - rai::store_iterator begin (rai::transaction const &); - rai::store_iterator end (); - void derive_key (rai::raw_key &, rai::transaction const &, std::string const &); - void serialize_json (rai::transaction const &, std::string &); - void write_backup (rai::transaction const &, boost::filesystem::path const &); - bool move (rai::transaction const &, rai::wallet_store &, std::vector const &); - bool import (rai::transaction const &, rai::wallet_store &); - bool work_get (rai::transaction const &, rai::public_key const &, uint64_t &); - void work_put (rai::transaction const &, rai::public_key const &, uint64_t); - unsigned version (rai::transaction const &); - void version_put (rai::transaction const &, unsigned); - void upgrade_v1_v2 (rai::transaction const &); - void upgrade_v2_v3 (rai::transaction const &); - void upgrade_v3_v4 (rai::transaction const &); - rai::fan password; - rai::fan wallet_key_mem; - static unsigned const version_1 = 1; - static unsigned const version_2 = 2; - static unsigned const version_3 = 3; - static unsigned const version_4 = 4; - unsigned const version_current = version_4; - static rai::uint256_union const version_special; - static rai::uint256_union const wallet_key_special; - static rai::uint256_union const salt_special; - static rai::uint256_union const check_special; - static rai::uint256_union const representative_special; - static rai::uint256_union const seed_special; - static rai::uint256_union const deterministic_index_special; - static size_t const check_iv_index; - static size_t const seed_iv_index; - static int const special_count; - static unsigned const kdf_full_work = 64 * 1024; - static unsigned const kdf_test_work = 8; - static unsigned const kdf_work = rai::rai_network == rai::rai_networks::rai_test_network ? kdf_test_work : kdf_full_work; - rai::kdf & kdf; - MDB_dbi handle; - std::recursive_mutex mutex; - -private: - MDB_txn * tx (rai::transaction const &) const; -}; -class wallets; -// A wallet is a set of account keys encrypted by a common encryption key -class wallet : public std::enable_shared_from_this -{ -public: - std::shared_ptr change_action (rai::account const &, rai::account const &, bool = true); - std::shared_ptr receive_action (rai::block const &, rai::account const &, rai::uint128_union const &, bool = true); - std::shared_ptr send_action (rai::account const &, rai::account const &, rai::uint128_t const &, bool = true, boost::optional = {}); - wallet (bool &, rai::transaction &, rai::wallets &, std::string const &); - wallet (bool &, rai::transaction &, rai::wallets &, std::string const &, std::string const &); - void enter_initial_password (); - bool enter_password (rai::transaction const &, std::string const &); - rai::public_key insert_adhoc (rai::raw_key const &, bool = true); - rai::public_key insert_adhoc (rai::transaction const &, rai::raw_key const &, bool = true); - void insert_watch (rai::transaction const &, rai::public_key const &); - rai::public_key deterministic_insert (rai::transaction const &, bool = true); - rai::public_key deterministic_insert (bool = true); - bool exists (rai::public_key const &); - bool import (std::string const &, std::string const &); - void serialize (std::string &); - bool change_sync (rai::account const &, rai::account const &); - void change_async (rai::account const &, rai::account const &, std::function)> const &, bool = true); - bool receive_sync (std::shared_ptr, rai::account const &, rai::uint128_t const &); - void receive_async (std::shared_ptr, rai::account const &, rai::uint128_t const &, std::function)> const &, bool = true); - rai::block_hash send_sync (rai::account const &, rai::account const &, rai::uint128_t const &); - void send_async (rai::account const &, rai::account const &, rai::uint128_t const &, std::function)> const &, bool = true, boost::optional = {}); - void work_apply (rai::account const &, std::function); - void work_cache_blocking (rai::account const &, rai::block_hash const &); - void work_update (rai::transaction const &, rai::account const &, rai::block_hash const &, uint64_t); - void work_ensure (rai::account const &, rai::block_hash const &); - bool search_pending (); - void init_free_accounts (rai::transaction const &); - /** Changes the wallet seed and returns the first account */ - rai::public_key change_seed (rai::transaction const & transaction_a, rai::raw_key const & prv_a); - bool live (); - std::unordered_set free_accounts; - std::function lock_observer; - rai::wallet_store store; - rai::wallets & wallets; -}; -class node; - -/** - * The wallets set is all the wallets a node controls. - * A node may contain multiple wallets independently encrypted and operated. - */ -class wallets -{ -public: - wallets (bool &, rai::node &); - ~wallets (); - std::shared_ptr open (rai::uint256_union const &); - std::shared_ptr create (rai::uint256_union const &); - bool search_pending (rai::uint256_union const &); - void search_pending_all (); - void destroy (rai::uint256_union const &); - void do_wallet_actions (); - void queue_wallet_action (rai::uint128_t const &, std::shared_ptr, std::function const &); - void foreach_representative (rai::transaction const &, std::function const &); - bool exists (rai::transaction const &, rai::public_key const &); - void stop (); - void clear_send_ids (rai::transaction const &); - std::function observer; - std::unordered_map> items; - std::multimap, std::function>, std::greater> actions; - std::mutex mutex; - std::condition_variable condition; - rai::kdf kdf; - MDB_dbi handle; - MDB_dbi send_action_ids; - rai::node & node; - rai::mdb_env & env; - bool stopped; - boost::thread thread; - static rai::uint128_t const generate_priority; - static rai::uint128_t const high_priority; - - /** Start read-write transaction */ - rai::transaction tx_begin_write (); - - /** Start read-only transaction */ - rai::transaction tx_begin_read (); - - /** - * Start a read-only or read-write transaction - * @param write If true, start a read-write transaction - */ - rai::transaction tx_begin (bool write = false); -}; -} diff --git a/rai/rai_node/CMakeLists.txt b/rai/rai_node/CMakeLists.txt deleted file mode 100644 index a0a8a608..00000000 --- a/rai/rai_node/CMakeLists.txt +++ /dev/null @@ -1,30 +0,0 @@ -add_executable (rai_node - daemon.cpp - daemon.hpp - entry.cpp) - -target_link_libraries (rai_node - node - secure - argon2 - Boost::boost - ${PLATFORM_LIBS} -) - -target_compile_definitions(rai_node - PRIVATE - -DRAIBLOCKS_VERSION_MAJOR=${CPACK_PACKAGE_VERSION_MAJOR} - -DRAIBLOCKS_VERSION_MINOR=${CPACK_PACKAGE_VERSION_MINOR}) - -set_target_properties (rai_node - PROPERTIES - COMPILE_FLAGS - "-DQT_NO_KEYWORDS -DBOOST_ASIO_HAS_STD_ARRAY=1") - -if (RAIBLOCKS_GUI AND NOT APPLE) - install(TARGETS rai_node - RUNTIME DESTINATION bin - LIBRARY DESTINATION lib - ARCHIVE DESTINATION lib - ) -endif() diff --git a/rai/rai_wallet/plat/default/icon.cpp b/rai/rai_wallet/plat/default/icon.cpp deleted file mode 100644 index 34001a1f..00000000 --- a/rai/rai_wallet/plat/default/icon.cpp +++ /dev/null @@ -1,5 +0,0 @@ -#include - -void rai::set_application_icon (QApplication &) -{ -} diff --git a/rai/secure/blockstore.hpp b/rai/secure/blockstore.hpp deleted file mode 100644 index 2e4b53ea..00000000 --- a/rai/secure/blockstore.hpp +++ /dev/null @@ -1,306 +0,0 @@ -#pragma once - -#include -#include - -namespace rai -{ -class transaction; -class block_store; - -/** - * Summation visitor for blocks, supporting amount and balance computations. These - * computations are mutually dependant. The natural solution is to use mutual recursion - * between balance and amount visitors, but this leads to very deep stacks. Hence, the - * summation visitor uses an iterative approach. - */ -class summation_visitor : public rai::block_visitor -{ - enum summation_type - { - invalid = 0, - balance = 1, - amount = 2 - }; - - /** Represents an invocation frame */ - class frame - { - public: - frame (summation_type type_a, rai::block_hash balance_hash_a, rai::block_hash amount_hash_a) : - type (type_a), balance_hash (balance_hash_a), amount_hash (amount_hash_a) - { - } - - /** The summation type guides the block visitor handlers */ - summation_type type{ invalid }; - /** Accumulated balance or amount */ - rai::uint128_t sum{ 0 }; - /** The current balance hash */ - rai::block_hash balance_hash{ 0 }; - /** The current amount hash */ - rai::block_hash amount_hash{ 0 }; - /** If true, this frame is awaiting an invocation result */ - bool awaiting_result{ false }; - /** Set by the invoked frame, representing the return value */ - rai::uint128_t incoming_result{ 0 }; - }; - -public: - summation_visitor (rai::transaction const &, rai::block_store &); - virtual ~summation_visitor () = default; - /** Computes the balance as of \p block_hash */ - rai::uint128_t compute_balance (rai::block_hash const & block_hash); - /** Computes the amount delta between \p block_hash and its predecessor */ - rai::uint128_t compute_amount (rai::block_hash const & block_hash); - -protected: - rai::transaction const & transaction; - rai::block_store & store; - - /** The final result */ - rai::uint128_t result{ 0 }; - /** The current invocation frame */ - frame * current{ nullptr }; - /** Invocation frames */ - std::stack frames; - /** Push a copy of \p hash of the given summation \p type */ - rai::summation_visitor::frame push (rai::summation_visitor::summation_type type, rai::block_hash const & hash); - void sum_add (rai::uint128_t addend_a); - void sum_set (rai::uint128_t value_a); - /** The epilogue yields the result to previous frame, if any */ - void epilogue (); - - rai::uint128_t compute_internal (rai::summation_visitor::summation_type type, rai::block_hash const &); - void send_block (rai::send_block const &) override; - void receive_block (rai::receive_block const &) override; - void open_block (rai::open_block const &) override; - void change_block (rai::change_block const &) override; - void state_block (rai::state_block const &) override; -}; - -/** - * Determine the representative for this block - */ -class representative_visitor : public rai::block_visitor -{ -public: - representative_visitor (rai::transaction const & transaction_a, rai::block_store & store_a); - virtual ~representative_visitor () = default; - void compute (rai::block_hash const & hash_a); - void send_block (rai::send_block const & block_a) override; - void receive_block (rai::receive_block const & block_a) override; - void open_block (rai::open_block const & block_a) override; - void change_block (rai::change_block const & block_a) override; - void state_block (rai::state_block const & block_a) override; - rai::transaction const & transaction; - rai::block_store & store; - rai::block_hash current; - rai::block_hash result; -}; -template -class store_iterator_impl -{ -public: - virtual ~store_iterator_impl () = default; - virtual rai::store_iterator_impl & operator++ () = 0; - virtual bool operator== (rai::store_iterator_impl const & other_a) const = 0; - virtual bool is_end_sentinal () const = 0; - virtual void fill (std::pair &) const = 0; - rai::store_iterator_impl & operator= (rai::store_iterator_impl const &) = delete; - bool operator== (rai::store_iterator_impl const * other_a) const - { - return (other_a != nullptr && *this == *other_a) || (other_a == nullptr && is_end_sentinal ()); - } - bool operator!= (rai::store_iterator_impl const & other_a) const - { - return !(*this == other_a); - } -}; -/** - * Iterates the key/value pairs of a transaction - */ -template -class store_iterator -{ -public: - store_iterator (std::nullptr_t) - { - } - store_iterator (std::unique_ptr> impl_a) : - impl (std::move (impl_a)) - { - impl->fill (current); - } - store_iterator (rai::store_iterator && other_a) : - current (std::move (other_a.current)), - impl (std::move (other_a.impl)) - { - } - rai::store_iterator & operator++ () - { - ++*impl; - impl->fill (current); - return *this; - } - rai::store_iterator & operator= (rai::store_iterator && other_a) - { - impl = std::move (other_a.impl); - current = std::move (other_a.current); - return *this; - } - rai::store_iterator & operator= (rai::store_iterator const &) = delete; - std::pair * operator-> () - { - return ¤t; - } - bool operator== (rai::store_iterator const & other_a) const - { - return (impl == nullptr && other_a.impl == nullptr) || (impl != nullptr && *impl == other_a.impl.get ()) || (other_a.impl != nullptr && *other_a.impl == impl.get ()); - } - bool operator!= (rai::store_iterator const & other_a) const - { - return !(*this == other_a); - } - -private: - std::pair current; - std::unique_ptr> impl; -}; - -class block_predecessor_set; - -class transaction_impl -{ -public: - virtual ~transaction_impl () = default; -}; -/** - * RAII wrapper of MDB_txn where the constructor starts the transaction - * and the destructor commits it. - */ -class transaction -{ -public: - std::unique_ptr impl; -}; - -/** - * Manages block storage and iteration - */ -class block_store -{ -public: - virtual ~block_store () = default; - virtual void initialize (rai::transaction const &, rai::genesis const &) = 0; - virtual void block_put (rai::transaction const &, rai::block_hash const &, rai::block const &, rai::block_hash const & = rai::block_hash (0), rai::epoch version = rai::epoch::epoch_0) = 0; - virtual rai::block_hash block_successor (rai::transaction const &, rai::block_hash const &) = 0; - virtual void block_successor_clear (rai::transaction const &, rai::block_hash const &) = 0; - virtual std::shared_ptr block_get (rai::transaction const &, rai::block_hash const &) = 0; - virtual std::shared_ptr block_random (rai::transaction const &) = 0; - virtual void block_del (rai::transaction const &, rai::block_hash const &) = 0; - virtual bool block_exists (rai::transaction const &, rai::block_hash const &) = 0; - virtual bool block_exists (rai::transaction const &, rai::block_type, rai::block_hash const &) = 0; - virtual rai::block_counts block_count (rai::transaction const &) = 0; - virtual bool root_exists (rai::transaction const &, rai::uint256_union const &) = 0; - - virtual void frontier_put (rai::transaction const &, rai::block_hash const &, rai::account const &) = 0; - virtual rai::account frontier_get (rai::transaction const &, rai::block_hash const &) = 0; - virtual void frontier_del (rai::transaction const &, rai::block_hash const &) = 0; - - virtual void account_put (rai::transaction const &, rai::account const &, rai::account_info const &) = 0; - virtual bool account_get (rai::transaction const &, rai::account const &, rai::account_info &) = 0; - virtual void account_del (rai::transaction const &, rai::account const &) = 0; - virtual bool account_exists (rai::transaction const &, rai::account const &) = 0; - virtual size_t account_count (rai::transaction const &) = 0; - virtual rai::store_iterator latest_v0_begin (rai::transaction const &, rai::account const &) = 0; - virtual rai::store_iterator latest_v0_begin (rai::transaction const &) = 0; - virtual rai::store_iterator latest_v0_end () = 0; - virtual rai::store_iterator latest_v1_begin (rai::transaction const &, rai::account const &) = 0; - virtual rai::store_iterator latest_v1_begin (rai::transaction const &) = 0; - virtual rai::store_iterator latest_v1_end () = 0; - virtual rai::store_iterator latest_begin (rai::transaction const &, rai::account const &) = 0; - virtual rai::store_iterator latest_begin (rai::transaction const &) = 0; - virtual rai::store_iterator latest_end () = 0; - - virtual void pending_put (rai::transaction const &, rai::pending_key const &, rai::pending_info const &) = 0; - virtual void pending_del (rai::transaction const &, rai::pending_key const &) = 0; - virtual bool pending_get (rai::transaction const &, rai::pending_key const &, rai::pending_info &) = 0; - virtual bool pending_exists (rai::transaction const &, rai::pending_key const &) = 0; - virtual rai::store_iterator pending_v0_begin (rai::transaction const &, rai::pending_key const &) = 0; - virtual rai::store_iterator pending_v0_begin (rai::transaction const &) = 0; - virtual rai::store_iterator pending_v0_end () = 0; - virtual rai::store_iterator pending_v1_begin (rai::transaction const &, rai::pending_key const &) = 0; - virtual rai::store_iterator pending_v1_begin (rai::transaction const &) = 0; - virtual rai::store_iterator pending_v1_end () = 0; - virtual rai::store_iterator pending_begin (rai::transaction const &, rai::pending_key const &) = 0; - virtual rai::store_iterator pending_begin (rai::transaction const &) = 0; - virtual rai::store_iterator pending_end () = 0; - - virtual void block_info_put (rai::transaction const &, rai::block_hash const &, rai::block_info const &) = 0; - virtual void block_info_del (rai::transaction const &, rai::block_hash const &) = 0; - virtual bool block_info_get (rai::transaction const &, rai::block_hash const &, rai::block_info &) = 0; - virtual bool block_info_exists (rai::transaction const &, rai::block_hash const &) = 0; - virtual rai::store_iterator block_info_begin (rai::transaction const &, rai::block_hash const &) = 0; - virtual rai::store_iterator block_info_begin (rai::transaction const &) = 0; - virtual rai::store_iterator block_info_end () = 0; - virtual rai::uint128_t block_balance (rai::transaction const &, rai::block_hash const &) = 0; - virtual rai::epoch block_version (rai::transaction const &, rai::block_hash const &) = 0; - static size_t const block_info_max = 32; - - virtual rai::uint128_t representation_get (rai::transaction const &, rai::account const &) = 0; - virtual void representation_put (rai::transaction const &, rai::account const &, rai::uint128_t const &) = 0; - virtual void representation_add (rai::transaction const &, rai::account const &, rai::uint128_t const &) = 0; - virtual rai::store_iterator representation_begin (rai::transaction const &) = 0; - virtual rai::store_iterator representation_end () = 0; - - virtual void unchecked_clear (rai::transaction const &) = 0; - virtual void unchecked_put (rai::transaction const &, rai::unchecked_key const &, std::shared_ptr const &) = 0; - virtual void unchecked_put (rai::transaction const &, rai::block_hash const &, std::shared_ptr const &) = 0; - virtual std::vector> unchecked_get (rai::transaction const &, rai::block_hash const &) = 0; - virtual bool unchecked_exists (rai::transaction const &, rai::unchecked_key const &) = 0; - virtual void unchecked_del (rai::transaction const &, rai::unchecked_key const &) = 0; - virtual rai::store_iterator> unchecked_begin (rai::transaction const &) = 0; - virtual rai::store_iterator> unchecked_begin (rai::transaction const &, rai::unchecked_key const &) = 0; - virtual rai::store_iterator> unchecked_end () = 0; - virtual size_t unchecked_count (rai::transaction const &) = 0; - - virtual void checksum_put (rai::transaction const &, uint64_t, uint8_t, rai::checksum const &) = 0; - virtual bool checksum_get (rai::transaction const &, uint64_t, uint8_t, rai::checksum &) = 0; - virtual void checksum_del (rai::transaction const &, uint64_t, uint8_t) = 0; - - // Return latest vote for an account from store - virtual std::shared_ptr vote_get (rai::transaction const &, rai::account const &) = 0; - // Populate vote with the next sequence number - virtual std::shared_ptr vote_generate (rai::transaction const &, rai::account const &, rai::raw_key const &, std::shared_ptr) = 0; - virtual std::shared_ptr vote_generate (rai::transaction const &, rai::account const &, rai::raw_key const &, std::vector) = 0; - // Return either vote or the stored vote with a higher sequence number - virtual std::shared_ptr vote_max (rai::transaction const &, std::shared_ptr) = 0; - // Return latest vote for an account considering the vote cache - virtual std::shared_ptr vote_current (rai::transaction const &, rai::account const &) = 0; - virtual void flush (rai::transaction const &) = 0; - virtual rai::store_iterator> vote_begin (rai::transaction const &) = 0; - virtual rai::store_iterator> vote_end () = 0; - - virtual void version_put (rai::transaction const &, int) = 0; - virtual int version_get (rai::transaction const &) = 0; - - // Requires a write transaction - virtual rai::raw_key get_node_id (rai::transaction const &) = 0; - - /** Deletes the node ID from the store */ - virtual void delete_node_id (rai::transaction const &) = 0; - - /** Start read-write transaction */ - virtual rai::transaction tx_begin_write () = 0; - - /** Start read-only transaction */ - virtual rai::transaction tx_begin_read () = 0; - - /** - * Start a read-only or read-write transaction - * @param write If true, start a read-write transaction - */ - virtual rai::transaction tx_begin (bool write = false) = 0; -}; -} diff --git a/rai/secure/common.hpp b/rai/secure/common.hpp deleted file mode 100644 index cd7aab06..00000000 --- a/rai/secure/common.hpp +++ /dev/null @@ -1,256 +0,0 @@ -#pragma once - -#include -#include -#include - -#include -#include -#include - -#include - -#include - -namespace boost -{ -template <> -struct hash -{ - size_t operator() (rai::uint256_union const & value_a) const - { - std::hash hash; - return hash (value_a); - } -}; -} -namespace rai -{ -const uint8_t protocol_version = 0x0f; -const uint8_t protocol_version_min = 0x0d; -const uint8_t node_id_version = 0x0c; - -/* - * Do not bootstrap from nodes older than this version. - * Also, on the beta network do not process messages from - * nodes older than this version. - */ -const uint8_t protocol_version_reasonable_min = 0x0d; - -/** - * A key pair. The private key is generated from the random pool, or passed in - * as a hex string. The public key is derived using ed25519. - */ -class keypair -{ -public: - keypair (); - keypair (std::string const &); - keypair (rai::raw_key &&); - rai::public_key pub; - rai::raw_key prv; -}; - -/** - * Tag for which epoch an entry belongs to - */ -enum class epoch : uint8_t -{ - invalid = 0, - unspecified = 1, - epoch_0 = 2, - epoch_1 = 3 -}; - -/** - * Latest information about an account - */ -class account_info -{ -public: - account_info (); - account_info (rai::account_info const &) = default; - account_info (rai::block_hash const &, rai::block_hash const &, rai::block_hash const &, rai::amount const &, uint64_t, uint64_t, epoch); - void serialize (rai::stream &) const; - bool deserialize (rai::stream &); - bool operator== (rai::account_info const &) const; - bool operator!= (rai::account_info const &) const; - size_t db_size () const; - rai::block_hash head; - rai::block_hash rep_block; - rai::block_hash open_block; - rai::amount balance; - /** Seconds since posix epoch */ - uint64_t modified; - uint64_t block_count; - rai::epoch epoch; -}; - -/** - * Information on an uncollected send - */ -class pending_info -{ -public: - pending_info (); - pending_info (rai::account const &, rai::amount const &, epoch); - void serialize (rai::stream &) const; - bool deserialize (rai::stream &); - bool operator== (rai::pending_info const &) const; - rai::account source; - rai::amount amount; - rai::epoch epoch; -}; -class pending_key -{ -public: - pending_key (); - pending_key (rai::account const &, rai::block_hash const &); - void serialize (rai::stream &) const; - bool deserialize (rai::stream &); - bool operator== (rai::pending_key const &) const; - rai::account account; - rai::block_hash hash; - rai::block_hash key () const; -}; -// Internally unchecked_key is equal to pending_key (2x uint256_union) -using unchecked_key = pending_key; - -class block_info -{ -public: - block_info (); - block_info (rai::account const &, rai::amount const &); - void serialize (rai::stream &) const; - bool deserialize (rai::stream &); - bool operator== (rai::block_info const &) const; - rai::account account; - rai::amount balance; -}; -class block_counts -{ -public: - block_counts (); - size_t sum (); - size_t send; - size_t receive; - size_t open; - size_t change; - size_t state_v0; - size_t state_v1; -}; -typedef std::vector, rai::block_hash>>::const_iterator vote_blocks_vec_iter; -class iterate_vote_blocks_as_hash -{ -public: - iterate_vote_blocks_as_hash () = default; - rai::block_hash operator() (boost::variant, rai::block_hash> const & item) const; -}; -class vote -{ -public: - vote () = default; - vote (rai::vote const &); - vote (bool &, rai::stream &, rai::block_uniquer * = nullptr); - vote (bool &, rai::stream &, rai::block_type, rai::block_uniquer * = nullptr); - vote (rai::account const &, rai::raw_key const &, uint64_t, std::shared_ptr); - vote (rai::account const &, rai::raw_key const &, uint64_t, std::vector); - std::string hashes_string () const; - rai::uint256_union hash () const; - rai::uint256_union full_hash () const; - bool operator== (rai::vote const &) const; - bool operator!= (rai::vote const &) const; - void serialize (rai::stream &, rai::block_type); - void serialize (rai::stream &); - bool deserialize (rai::stream &, rai::block_uniquer * = nullptr); - bool validate (); - boost::transform_iterator begin () const; - boost::transform_iterator end () const; - std::string to_json () const; - // Vote round sequence number - uint64_t sequence; - // The blocks, or block hashes, that this vote is for - std::vector, rai::block_hash>> blocks; - // Account that's voting - rai::account account; - // Signature of sequence + block hashes - rai::signature signature; - static const std::string hash_prefix; -}; -/** - * This class serves to find and return unique variants of a vote in order to minimize memory usage - */ -class vote_uniquer -{ -public: - vote_uniquer (rai::block_uniquer &); - std::shared_ptr unique (std::shared_ptr); - size_t size (); - -private: - rai::block_uniquer & uniquer; - std::mutex mutex; - std::unordered_map> votes; - static unsigned constexpr cleanup_count = 2; -}; -enum class vote_code -{ - invalid, // Vote is not signed correctly - replay, // Vote does not have the highest sequence number, it's a replay - vote // Vote has the highest sequence number -}; - -enum class process_result -{ - progress, // Hasn't been seen before, signed correctly - bad_signature, // Signature was bad, forged or transmission error - old, // Already seen and was valid - negative_spend, // Malicious attempt to spend a negative amount - fork, // Malicious fork based on previous - unreceivable, // Source block doesn't exist, has already been received, or requires an account upgrade (epoch blocks) - gap_previous, // Block marked as previous is unknown - gap_source, // Block marked as source is unknown - opened_burn_account, // The impossible happened, someone found the private key associated with the public key '0'. - balance_mismatch, // Balance and amount delta don't match - representative_mismatch, // Representative is changed when it is not allowed - block_position // This block cannot follow the previous block -}; -class process_return -{ -public: - rai::process_result code; - rai::account account; - rai::amount amount; - rai::account pending_account; - boost::optional state_is_send; -}; -enum class tally_result -{ - vote, - changed, - confirm -}; -extern rai::keypair const & zero_key; -extern rai::keypair const & test_genesis_key; -extern rai::account const & rai_test_account; -extern rai::account const & rai_beta_account; -extern rai::account const & rai_live_account; -extern std::string const & rai_test_genesis; -extern std::string const & rai_beta_genesis; -extern std::string const & rai_live_genesis; -extern std::string const & genesis_block; -extern rai::account const & genesis_account; -extern rai::account const & burn_account; -extern rai::uint128_t const & genesis_amount; -// A block hash that compares inequal to any real block hash -extern rai::block_hash const & not_a_block; -// An account number that compares inequal to any real account number -extern rai::block_hash const & not_an_account; -class genesis -{ -public: - explicit genesis (); - rai::block_hash hash () const; - std::shared_ptr open; -}; -} diff --git a/rai/secure/ledger.hpp b/rai/secure/ledger.hpp deleted file mode 100644 index a22dce43..00000000 --- a/rai/secure/ledger.hpp +++ /dev/null @@ -1,57 +0,0 @@ -#pragma once - -#include - -namespace rai -{ -class block_store; -class stat; - -class shared_ptr_block_hash -{ -public: - size_t operator() (std::shared_ptr const &) const; - bool operator() (std::shared_ptr const &, std::shared_ptr const &) const; -}; -using tally_t = std::map, std::greater>; -class ledger -{ -public: - ledger (rai::block_store &, rai::stat &, rai::uint256_union const & = 1, rai::account const & = 0); - rai::account account (rai::transaction const &, rai::block_hash const &); - rai::uint128_t amount (rai::transaction const &, rai::block_hash const &); - rai::uint128_t balance (rai::transaction const &, rai::block_hash const &); - rai::uint128_t account_balance (rai::transaction const &, rai::account const &); - rai::uint128_t account_pending (rai::transaction const &, rai::account const &); - rai::uint128_t weight (rai::transaction const &, rai::account const &); - std::shared_ptr successor (rai::transaction const &, rai::block_hash const &); - std::shared_ptr forked_block (rai::transaction const &, rai::block const &); - rai::block_hash latest (rai::transaction const &, rai::account const &); - rai::block_hash latest_root (rai::transaction const &, rai::account const &); - rai::block_hash representative (rai::transaction const &, rai::block_hash const &); - rai::block_hash representative_calculated (rai::transaction const &, rai::block_hash const &); - bool block_exists (rai::block_hash const &); - bool block_exists (rai::block_type, rai::block_hash const &); - std::string block_text (char const *); - std::string block_text (rai::block_hash const &); - bool is_send (rai::transaction const &, rai::state_block const &); - rai::block_hash block_destination (rai::transaction const &, rai::block const &); - rai::block_hash block_source (rai::transaction const &, rai::block const &); - rai::process_return process (rai::transaction const &, rai::block const &, bool = false); - void rollback (rai::transaction const &, rai::block_hash const &); - void change_latest (rai::transaction const &, rai::account const &, rai::block_hash const &, rai::account const &, rai::uint128_union const &, uint64_t, bool = false, rai::epoch = rai::epoch::epoch_0); - void checksum_update (rai::transaction const &, rai::block_hash const &); - rai::checksum checksum (rai::transaction const &, rai::account const &, rai::account const &); - void dump_account_chain (rai::account const &); - bool could_fit (rai::transaction const &, rai::block const &); - bool is_epoch_link (rai::uint256_union const &); - static rai::uint128_t const unit; - rai::block_store & store; - rai::stat & stats; - std::unordered_map bootstrap_weights; - uint64_t bootstrap_weight_max_blocks; - std::atomic check_bootstrap_weights; - rai::uint256_union epoch_link; - rai::account epoch_signer; -}; -}; diff --git a/rai/secure/versioning.hpp b/rai/secure/versioning.hpp deleted file mode 100644 index 5b50bd32..00000000 --- a/rai/secure/versioning.hpp +++ /dev/null @@ -1,55 +0,0 @@ -#pragma once - -#include -#include -#include - -namespace rai -{ -class account_info_v1 -{ -public: - account_info_v1 (); - account_info_v1 (MDB_val const &); - account_info_v1 (rai::account_info_v1 const &) = default; - account_info_v1 (rai::block_hash const &, rai::block_hash const &, rai::amount const &, uint64_t); - void serialize (rai::stream &) const; - bool deserialize (rai::stream &); - rai::mdb_val val () const; - rai::block_hash head; - rai::block_hash rep_block; - rai::amount balance; - uint64_t modified; -}; -class pending_info_v3 -{ -public: - pending_info_v3 (); - pending_info_v3 (MDB_val const &); - pending_info_v3 (rai::account const &, rai::amount const &, rai::account const &); - void serialize (rai::stream &) const; - bool deserialize (rai::stream &); - bool operator== (rai::pending_info_v3 const &) const; - rai::mdb_val val () const; - rai::account source; - rai::amount amount; - rai::account destination; -}; -// Latest information about an account -class account_info_v5 -{ -public: - account_info_v5 (); - account_info_v5 (MDB_val const &); - account_info_v5 (rai::account_info_v5 const &) = default; - account_info_v5 (rai::block_hash const &, rai::block_hash const &, rai::block_hash const &, rai::amount const &, uint64_t); - void serialize (rai::stream &) const; - bool deserialize (rai::stream &); - rai::mdb_val val () const; - rai::block_hash head; - rai::block_hash rep_block; - rai::block_hash open_block; - rai::amount balance; - uint64_t modified; -}; -} diff --git a/util/build_prep/macosx/prep.sh.in b/util/build_prep/macosx/prep.sh.in index d7063324..c3b8a086 100644 --- a/util/build_prep/macosx/prep.sh.in +++ b/util/build_prep/macosx/prep.sh.in @@ -124,7 +124,7 @@ echo "Next steps:" echo " CC='${CC:-cc} ${wrap_compilers_add_options[*]}'" echo " CXX='${CXX:-c++} ${wrap_compilers_add_options[*]}'" echo " export CC CXX" -echo " cmake -DBOOST_ROOT=${boost_dir} -DRAIBLOCKS_GUI=ON -DQt5_DIR=${qt5_dir} " +echo " cmake -DBOOST_ROOT=${boost_dir} -DNANO_GUI=ON -DQt5_DIR=${qt5_dir} " echo " cpack -G \"DragNDrop\"" exit 0 diff --git a/util/build_prep/ubuntu/prep.sh.in b/util/build_prep/ubuntu/prep.sh.in index 8f71e592..7fac61cb 100644 --- a/util/build_prep/ubuntu/prep.sh.in +++ b/util/build_prep/ubuntu/prep.sh.in @@ -64,7 +64,7 @@ fi echo "All verified." echo "" echo "Next steps:" -echo " cmake -DBOOST_ROOT=${boost_dir} -DRAIBLOCKS_GUI=ON ${cmake_add} " +echo " cmake -DBOOST_ROOT=${boost_dir} -DNANO_GUI=ON ${cmake_add} " echo " cpack -G \"TBZ2\"" exit 0