Rename internal project bits from RaiBlocks to Nano (#1504)

.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.
 
 <!--
 
-Can you please provide the RaiBlocks logs for further analysis.
+Can you please provide the Nano logs for further analysis.
 
-How to find RaiBlocks logs:
+How to find Nano logs:
     
-https://github.com/clemahieu/raiblocks/wiki/Log-files
+https://github.com/nanocurrency/raiblocks/wiki/Log-files
 
 -->

.gitignore

@@ -30,8 +30,8 @@
 core_test
 !core_test/
 qt_test
-rai_node
-rai_wallet
+nano_node
+nano_wallet
 slow_test
 
 # IDEs

.gitlab-ci.yml

@@ -1,4 +1,4 @@
-## Raiblocks CI config
+## Nano CI config
 
 image: ubuntu:xenial
 

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}")

Info.plist

@@ -13,9 +13,9 @@
 	<key>CFBundleInfoDictionaryVersion</key>
 	<string>6.0</string>
 	<key>CFBundleIconFile</key>
-	<string>RaiBlocks.icns</string>
+	<string>Nano.icns</string>
 	<key>CFBundleIdentifier</key>
-	<string>net.raiblocks.rai_wallet</string>
+	<string>org.nano.nano_wallet</string>
 	<key>NSRequiresAquaSystemAppearance</key>
 	<true/>
 </dict>

Nano.rc

@@ -0,0 +1 @@
+1 ICON "Nano.ico"

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?

RaiBlocks.rc

@@ -1 +0,0 @@
-1 ICON "RaiBlocks.ico"

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%
 
 
 

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" \

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

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

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}"

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

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"]

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

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

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

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)",

load-tester/Cargo.toml

@@ -1,5 +1,5 @@
 [package]
-name = "raiblocks-load-tester"
+name = "nano-load-tester"
 version = "0.1.0"
 
 [dependencies]

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<C: Connect>(
         "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 _
 }

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")

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)

nano/core_test/block.cpp

@@ -3,20 +3,20 @@
 #include <fstream>
 
 #include <gtest/gtest.h>
-#include <rai/core_test/testutil.hpp>
+#include <nano/core_test/testutil.hpp>
 
-#include <rai/lib/interface.h>
-#include <rai/node/common.hpp>
-#include <rai/node/node.hpp>
+#include <nano/lib/interface.h>
+#include <nano/node/common.hpp>
+#include <nano/node/node.hpp>
 
 #include <ed25519-donna/ed25519.h>
 
 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<uint8_t> 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<uint8_t> 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<rai::uint512_t>::max ());
+	nano::uint512_union input (std::numeric_limits<nano::uint512_t>::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<rai::uint512_t>::max ());
+	nano::uint512_union input (std::numeric_limits<nano::uint512_t>::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<uint8_t> 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<uint8_t> 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<uint8_t> 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<uint8_t> 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<uint8_t> 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<rai::send_block> (0, key2.pub, 200, rai::keypair ().prv, 2, 3));
-	rai::publish req (block);
+	nano::keypair key1;
+	nano::keypair key2;
+	auto block (std::make_shared<nano::send_block> (0, key2.pub, 200, nano::keypair ().prv, 2, 3));
+	nano::publish req (block);
 	std::vector<uint8_t> 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<rai::send_block> (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<nano::send_block> (0, key2.pub, 200, nano::keypair ().prv, 2, 3));
+	nano::confirm_req req (block);
 	std::vector<uint8_t> 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<uint8_t> 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<rai::state_block> (0, 0, 0, 0, 0, key.prv, key.pub, 0));
-	auto block2 (std::make_shared<rai::state_block> (*block1));
+	nano::keypair key;
+	auto block1 (std::make_shared<nano::state_block> (0, 0, 0, 0, 0, key.prv, key.pub, 0));
+	auto block2 (std::make_shared<nano::state_block> (*block1));
 	ASSERT_NE (block1, block2);
 	ASSERT_EQ (*block1, *block2);
-	std::weak_ptr<rai::state_block> block3 (block2);
+	std::weak_ptr<nano::state_block> 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<rai::state_block> (0, 0, 0, 0, 0, key.prv, key.pub, 0));
-	auto block2 (std::make_shared<rai::state_block> (0, 0, 0, 0, 0, key.prv, key.pub, 1));
-	rai::block_uniquer uniquer;
+	nano::keypair key;
+	auto block1 (std::make_shared<nano::state_block> (0, 0, 0, 0, 0, key.prv, key.pub, 0));
+	auto block2 (std::make_shared<nano::state_block> (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<rai::state_block> (0, 0, 0, 0, 0, key.prv, key.pub, 0));
+	auto zero_block_manual (std::make_shared<nano::state_block> (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")

nano/core_test/conflicts.cpp

@@ -0,0 +1,175 @@
+#include <gtest/gtest.h>
+#include <nano/node/testing.hpp>
+
+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<nano::send_block> (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<nano::send_block> (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<nano::send_block> (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<nano::vote> (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<nano::send_block> (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<nano::send_block> (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<nano::vote> (key.pub, key.prv, 0, std::make_shared<nano::state_block> (0, 0, 0, 0, 0, key.prv, key.pub, 0)));
+	auto vote2 (std::make_shared<nano::vote> (*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<nano::state_block> (0, 0, 0, 0, 0, key1.prv, key1.pub, 0));
+	auto block2 (std::make_shared<nano::state_block> (*block1));
+	auto vote1 (std::make_shared<nano::vote> (key1.pub, key1.prv, 0, block1));
+	auto vote2 (std::make_shared<nano::vote> (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<std::shared_ptr<nano::block>> (vote1->blocks[0]), boost::get<std::shared_ptr<nano::block>> (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<nano::state_block> (0, 0, 0, 0, 0, key.prv, key.pub, 0));
+	std::vector<nano::block_hash> hashes;
+	hashes.push_back (block->hash ());
+	auto vote1 (std::make_shared<nano::vote> (key.pub, key.prv, 0, hashes));
+	auto vote2 (std::make_shared<nano::vote> (*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<nano::state_block> (0, 0, 0, 0, 0, key.prv, key.pub, 0));
+	std::vector<nano::block_hash> hashes1;
+	hashes1.push_back (block1->hash ());
+	auto block2 (std::make_shared<nano::state_block> (1, 0, 0, 0, 0, key.prv, key.pub, 0));
+	std::vector<nano::block_hash> hashes2;
+	hashes2.push_back (block2->hash ());
+	auto vote1 (std::make_shared<nano::vote> (key.pub, key.prv, 0, hashes1));
+	auto vote2 (std::make_shared<nano::vote> (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<nano::vote> (key.pub, key.prv, 0, std::make_shared<nano::state_block> (0, 0, 0, 0, 0, key.prv, key.pub, 0)));
+	auto vote2 (std::make_shared<nano::vote> (key.pub, key.prv, 1, std::make_shared<nano::state_block> (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<nano::send_block> (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);
+}

nano/core_test/gap_cache.cpp

@@ -1,23 +1,23 @@
 #include <gtest/gtest.h>
-#include <rai/core_test/testutil.hpp>
-#include <rai/node/testing.hpp>
+#include <nano/core_test/testutil.hpp>
+#include <nano/node/testing.hpp>
 
 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<rai::send_block> (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<nano::send_block> (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<rai::send_block> (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<nano::send_block> (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<rai::send_block> (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<nano::send_block> (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<rai::send_block> (0, 42, 1, rai::keypair ().prv, 3, 4));
+	auto block3 (std::make_shared<nano::send_block> (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<rai::send_block> (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<nano::send_block> (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<rai::send_block> (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<rai::send_block> (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<rai::open_block> (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<nano::send_block> (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<nano::send_block> (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<nano::open_block> (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 ();

nano/core_test/interface.cpp

@@ -2,14 +2,14 @@
 
 #include <memory>
 
-#include <rai/lib/blocks.hpp>
-#include <rai/lib/interface.h>
-#include <rai/lib/numbers.hpp>
-#include <rai/lib/work.hpp>
+#include <nano/lib/blocks.hpp>
+#include <nano/lib/interface.h>
+#include <nano/lib/numbers.hpp>
+#include <nano/lib/work.hpp>
 
 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<rai::send_block *> (block.get ()));
+	auto send1 (dynamic_cast<nano::send_block *> (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 ("");
 }

nano/core_test/message.cpp

@@ -0,0 +1,85 @@
+#include <gtest/gtest.h>
+
+#include <nano/node/common.hpp>
+
+TEST (message, keepalive_serialization)
+{
+	nano::keepalive request1;
+	std::vector<uint8_t> 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<uint8_t> 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<nano::send_block> (0, 1, 2, nano::keypair ().prv, 4, 5));
+	ASSERT_EQ (nano::block_type::send, publish.header.block_type ());
+	std::vector<uint8_t> 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<uint8_t> (nano::message_type::publish), bytes[5]);
+	ASSERT_EQ (0x00, bytes[6]); // extensions
+	ASSERT_EQ (static_cast<uint8_t> (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<nano::vote> (key1.pub, key1.prv, 0, std::make_shared<nano::send_block> (0, 1, 2, key1.prv, 4, 5)));
+	nano::confirm_ack con1 (vote);
+	std::vector<uint8_t> 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);
+}

nano/core_test/message_parser.cpp

@@ -0,0 +1,200 @@
+#include <gtest/gtest.h>
+#include <nano/node/testing.hpp>
+
+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<nano::send_block> (1, 1, 2, nano::keypair ().prv, 4, system.work.generate (1)));
+	auto vote (std::make_shared<nano::vote> (0, nano::keypair ().prv, 0, std::move (block)));
+	nano::confirm_ack message (vote);
+	std::vector<uint8_t> 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<nano::send_block> (1, 1, 2, nano::keypair ().prv, 4, system.work.generate (1)));
+	nano::confirm_req message (std::move (block));
+	std::vector<uint8_t> 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<nano::send_block> (1, 1, 2, nano::keypair ().prv, 4, system.work.generate (1)));
+	nano::publish message (std::move (block));
+	std::vector<uint8_t> 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<uint8_t> 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);
+}

nano/core_test/peer_container.cpp

@@ -0,0 +1,171 @@
+#include <gtest/gtest.h>
+#include <nano/node/node.hpp>
+
+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<nano::endpoint, 8> 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<nano::endpoint, 8> 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<nano::endpoint, 8> 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 ());
+}

nano/core_test/processor_service.cpp

@@ -1,5 +1,5 @@
 #include <gtest/gtest.h>
-#include <rai/node/node.hpp>
+#include <nano/node/node.hpp>
 
 #include <atomic>
 #include <condition_variable>
@@ -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<bool> 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<int> 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;

nano/core_test/signing.cpp

@@ -1,24 +1,24 @@
 #include <gtest/gtest.h>
 
 #include <future>
-#include <rai/node/node.hpp>
+#include <nano/node/node.hpp>
 
 TEST (signature_checker, empty)
 {
-	rai::signature_checker checker;
+	nano::signature_checker checker;
 	std::promise<void> 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<void> promise;
-	std::vector<rai::uint256_union> hashes;
+	std::vector<nano::uint256_union> hashes;
 	size_t size (1000);
 	hashes.reserve (size);
 	std::vector<unsigned char const *> 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<void> promise;
-	std::vector<rai::uint256_union> hashes;
+	std::vector<nano::uint256_union> hashes;
 	std::vector<unsigned char const *> messages;
 	std::vector<size_t> lengths;
 	std::vector<unsigned char const *> 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 ();
 }

nano/core_test/uint256_union.cpp

@@ -1,7 +1,7 @@
 #include <gtest/gtest.h>
 
-#include <rai/lib/interface.h>
-#include <rai/secure/common.hpp>
+#include <nano/lib/interface.h>
+#include <nano/secure/common.hpp>
 
 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<rai::uint128_union, rai::uint128_t> ();
+	test_union_operator_less_than<nano::uint128_union, nano::uint128_t> ();
 }
 
 TEST (uint128_union, operator_greater_than)
 {
-	test_union_operator_greater_than<rai::uint128_union, rai::uint128_t> ();
+	test_union_operator_greater_than<nano::uint128_union, nano::uint128_t> ();
 }
 
 struct test_punct : std::moneypunct<char>
@@ -97,66 +97,66 @@ struct test_punct : std::moneypunct<char>
 
 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<uint8_t> ());
-	ASSERT_EQ (1, rai::uint256_union (1).number ().convert_to<uint8_t> ());
-	ASSERT_EQ (1, rai::uint512_union (1).number ().convert_to<uint8_t> ());
+	ASSERT_EQ (1, nano::uint128_union (1).number ().convert_to<uint8_t> ());
+	ASSERT_EQ (1, nano::uint256_union (1).number ().convert_to<uint8_t> ());
+	ASSERT_EQ (1, nano::uint512_union (1).number ().convert_to<uint8_t> ());
 }
 
 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<rai::uint256_t>::max ());
+	nano::uint256_union input (std::numeric_limits<nano::uint256_t>::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<rai::uint256_t>::max ());
+	nano::uint256_union input (std::numeric_limits<nano::uint256_t>::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<rai::uint256_t>::max ());
+	nano::uint256_union input (std::numeric_limits<nano::uint256_t>::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<rai::uint256_union, rai::uint256_t> ();
+	test_union_operator_less_than<nano::uint256_union, nano::uint256_t> ();
 }
 
 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<std::string> ("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<std::string> ("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 <typename Union, typename Bound>
 void assert_union_types ()
 {
-	static_assert ((std::is_same<Union, rai::uint128_union>::value && std::is_same<Bound, rai::uint128_t>::value) || (std::is_same<Union, rai::uint256_union>::value && std::is_same<Bound, rai::uint256_t>::value) || (std::is_same<Union, rai::uint512_union>::value && std::is_same<Bound, rai::uint512_t>::value),
+	static_assert ((std::is_same<Union, nano::uint128_union>::value && std::is_same<Bound, nano::uint128_t>::value) || (std::is_same<Union, nano::uint256_union>::value && std::is_same<Bound, nano::uint256_t>::value) || (std::is_same<Union, nano::uint512_union>::value && std::is_same<Bound, nano::uint512_t>::value),
 	"Union type needs to be consistent with the lower/upper Bound type");
 }
 

nano/core_test/versioning.cpp

@@ -1,30 +1,30 @@
 #include <gtest/gtest.h>
 
-#include <rai/secure/blockstore.hpp>
-#include <rai/secure/versioning.hpp>
+#include <nano/secure/blockstore.hpp>
+#include <nano/secure/versioning.hpp>
 
 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);

nano/core_test/wallets.cpp

@@ -1,18 +1,18 @@
 #include <gtest/gtest.h>
 
-#include <rai/core_test/testutil.hpp>
-#include <rai/node/testing.hpp>
+#include <nano/core_test/testutil.hpp>
+#include <nano/node/testing.hpp>
 
 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 ());

nano/core_test/work_pool.cpp

@@ -1,38 +1,38 @@
 #include <gtest/gtest.h>
 
-#include <rai/node/node.hpp>
-#include <rai/node/wallet.hpp>
+#include <nano/node/node.hpp>
+#include <nano/node/wallet.hpp>
 
 TEST (work, one)
 {
-	rai::work_pool pool (std::numeric_limits<unsigned>::max (), nullptr);
-	rai::change_block block (1, 1, rai::keypair ().prv, 3, 4);
+	nano::work_pool pool (std::numeric_limits<unsigned>::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<unsigned>::max (), nullptr);
-	rai::send_block send_block (1, 1, 2, rai::keypair ().prv, 4, 6);
+	nano::work_pool pool (std::numeric_limits<unsigned>::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<unsigned>::max (), nullptr);
+	nano::work_pool pool (std::numeric_limits<unsigned>::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<uint64_t> work_a) {
 			done = !work_a;
 		});
@@ -44,13 +44,13 @@ TEST (work, cancel)
 
 TEST (work, cancel_many)
 {
-	rai::work_pool pool (std::numeric_limits<unsigned>::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<unsigned>::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<uint64_t>) {});
 	pool.generate (key2, [](boost::optional<uint64_t>) {});
 	pool.generate (key3, [](boost::optional<uint64_t>) {});
@@ -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<unsigned>::max (), opencl ? [&opencl](rai::uint256_union const & root_a) {
+		nano::work_pool pool (std::numeric_limits<unsigned>::max (), opencl ? [&opencl](nano::uint256_union const & root_a) {
 			return opencl->generate_work (root_a);
 		}
-		                                                                   : std::function<boost::optional<uint64_t> (rai::uint256_union const &)> (nullptr));
+		                                                                    : std::function<boost::optional<uint64_t> (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<unsigned>::max (), nullptr);
-	rai::uint256_union root (1);
+	nano::work_pool pool (std::numeric_limits<unsigned>::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);
 }

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

nano/lib/blockbuilders.cpp

@@ -1,6 +1,6 @@
 #include <cryptopp/osrng.h>
-#include <rai/lib/blockbuilders.hpp>
-#include <rai/secure/common.hpp>
+#include <nano/lib/blockbuilders.hpp>
+#include <nano/secure/common.hpp>
 #include <unordered_map>
 
 namespace
@@ -8,7 +8,7 @@ namespace
 template <typename BLOCKTYPE>
 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 <typename BLOCKTYPE>
 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 <typename BLOCKTYPE>
 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 <typename BLOCKTYPE>
 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 <typename BLOCKTYPE>
 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 <typename BLOCKTYPE>
 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 <typename BLOCKTYPE>
 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 <typename BLOCKTYPE>
 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 <typename BLOCKTYPE>
 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 <typename BLOCKTYPE>
 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<uint8_t, std::error_code> ec_map = {
-	{ static_cast<uint8_t> (rai::build_flags::account_present), nano::error_common::missing_account },
-	{ static_cast<uint8_t> (rai::build_flags::balance_present), nano::error_common::missing_balance },
-	{ static_cast<uint8_t> (rai::build_flags::link_present), nano::error_common::missing_link },
-	{ static_cast<uint8_t> (rai::build_flags::previous_present), nano::error_common::missing_previous },
-	{ static_cast<uint8_t> (rai::build_flags::representative_present), nano::error_common::missing_representative },
-	{ static_cast<uint8_t> (rai::build_flags::signature_present), nano::error_common::missing_signature },
-	{ static_cast<uint8_t> (rai::build_flags::work_present), nano::error_common::missing_work }
+	{ static_cast<uint8_t> (nano::build_flags::account_present), nano::error_common::missing_account },
+	{ static_cast<uint8_t> (nano::build_flags::balance_present), nano::error_common::missing_balance },
+	{ static_cast<uint8_t> (nano::build_flags::link_present), nano::error_common::missing_link },
+	{ static_cast<uint8_t> (nano::build_flags::previous_present), nano::error_common::missing_previous },
+	{ static_cast<uint8_t> (nano::build_flags::representative_present), nano::error_common::missing_representative },
+	{ static_cast<uint8_t> (nano::build_flags::signature_present), nano::error_common::missing_signature },
+	{ static_cast<uint8_t> (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;

nano/lib/blockbuilders.hpp

@@ -1,10 +1,10 @@
 #pragma once
 
 #include <memory>
-#include <rai/lib/blocks.hpp>
-#include <rai/lib/errors.hpp>
+#include <nano/lib/blocks.hpp>
+#include <nano/lib/errors.hpp>
 
-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<rai::build_flags> (static_cast<uint8_t> (a) | static_cast<uint8_t> (b));
+	return static_cast<nano::build_flags> (static_cast<uint8_t> (a) | static_cast<uint8_t> (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<uint8_t> (a | static_cast<uint8_t> (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<uint8_t> (a & static_cast<uint8_t> (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<uint8_t> (a | static_cast<uint8_t> (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<uint8_t> (rai::build_flags::work_present | rai::build_flags::signature_present);
+	uint8_t base_fields = static_cast<uint8_t> (nano::build_flags::work_present | nano::build_flags::signature_present);
 };
 
 /** Builder for state blocks */
-class state_block_builder : public abstract_builder<rai::state_block, state_block_builder>
+class state_block_builder : public abstract_builder<nano::state_block, state_block_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<uint8_t> (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<uint8_t> (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<rai::open_block, open_block_builder>
+class open_block_builder : public abstract_builder<nano::open_block, open_block_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<uint8_t> (rai::build_flags::account_present | rai::build_flags::representative_present | rai::build_flags::link_present);
+	uint8_t required_fields = base_fields | static_cast<uint8_t> (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<rai::change_block, change_block_builder>
+class change_block_builder : public abstract_builder<nano::change_block, change_block_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<uint8_t> (rai::build_flags::previous_present | rai::build_flags::representative_present);
+	uint8_t required_fields = base_fields | static_cast<uint8_t> (nano::build_flags::previous_present | nano::build_flags::representative_present);
 };
 
 /** Builder for send blocks */
-class send_block_builder : public abstract_builder<rai::send_block, send_block_builder>
+class send_block_builder : public abstract_builder<nano::send_block, send_block_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<rai::receive_block, receive_block_builder>
+class receive_block_builder : public abstract_builder<nano::receive_block, receive_block_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;
 };
 }

nano/lib/blocks.hpp

@@ -0,0 +1,336 @@
+#pragma once
+
+#include <nano/lib/numbers.hpp>
+
+#include <assert.h>
+#include <blake2/blake2.h>
+#include <boost/property_tree/json_parser.hpp>
+#include <streambuf>
+#include <unordered_map>
+
+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<uint8_t>;
+// Read a raw byte stream the size of `T' and fill value.
+template <typename T>
+bool read (nano::stream & stream_a, T & value)
+{
+	static_assert (std::is_pod<T>::value, "Can't stream read non-standard layout types");
+	auto amount_read (stream_a.sgetn (reinterpret_cast<uint8_t *> (&value), sizeof (value)));
+	return amount_read != sizeof (value);
+}
+template <typename T>
+void write (nano::stream & stream_a, T const & value)
+{
+	static_assert (std::is_pod<T>::value, "Can't stream write non-standard layout types");
+	auto amount_written (stream_a.sputn (reinterpret_cast<uint8_t const *> (&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<nano::block> unique (std::shared_ptr<nano::block>);
+	size_t size ();
+
+private:
+	std::mutex mutex;
+	std::unordered_map<nano::uint256_union, std::weak_ptr<nano::block>> blocks;
+	static unsigned constexpr cleanup_count = 2;
+};
+std::shared_ptr<nano::block> deserialize_block (nano::stream &, nano::block_uniquer * = nullptr);
+std::shared_ptr<nano::block> deserialize_block (nano::stream &, nano::block_type, nano::block_uniquer * = nullptr);
+std::shared_ptr<nano::block> deserialize_block_json (boost::property_tree::ptree const &, nano::block_uniquer * = nullptr);
+void serialize_block (nano::stream &, nano::block const &);
+}

nano/lib/config.hpp

@@ -3,21 +3,24 @@
 #include <chrono>
 #include <cstddef>
 
-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);
 }

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
 {

nano/lib/errors.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <rai/lib/expected.hpp>
+#include <nano/lib/expected.hpp>
 #include <string>
 #include <system_error>
 #include <type_traits>

nano/lib/interface.cpp

@@ -1,4 +1,4 @@
-#include <rai/lib/interface.h>
+#include <nano/lib/interface.h>
 
 #include <xxhash/xxhash.h>
 
@@ -8,76 +8,76 @@
 
 #include <boost/property_tree/json_parser.hpp>
 
-#include <rai/lib/blocks.hpp>
-#include <rai/lib/numbers.hpp>
-#include <rai/lib/work.hpp>
+#include <nano/lib/blocks.hpp>
+#include <nano/lib/numbers.hpp>
+#include <nano/lib/work.hpp>
 
 #include <cstring>
 
 extern "C" {
 void xrb_uint128_to_dec (xrb_uint128 source, char * destination)
 {
-	auto const & number (*reinterpret_cast<rai::uint128_union *> (source));
+	auto const & number (*reinterpret_cast<nano::uint128_union *> (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<rai::uint256_union *> (source));
+	auto const & number (*reinterpret_cast<nano::uint256_union *> (source));
 	strncpy (destination, number.to_string ().c_str (), 64);
 }
 
 void xrb_uint256_to_address (xrb_uint256 source, char * destination)
 {
-	auto const & number (*reinterpret_cast<rai::uint256_union *> (source));
+	auto const & number (*reinterpret_cast<nano::uint256_union *> (source));
 	strncpy (destination, number.to_account ().c_str (), 65);
 }
 
 void xrb_uint512_to_string (xrb_uint512 source, char * destination)
 {
-	auto const & number (*reinterpret_cast<rai::uint512_union *> (source));
+	auto const & number (*reinterpret_cast<nano::uint512_union *> (source));
 	strncpy (destination, number.to_string ().c_str (), 128);
 }
 
 int xrb_uint128_from_dec (const char * source, xrb_uint128 destination)
 {
-	auto & number (*reinterpret_cast<rai::uint128_union *> (destination));
+	auto & number (*reinterpret_cast<nano::uint128_union *> (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<rai::uint256_union *> (destination));
+	auto & number (*reinterpret_cast<nano::uint256_union *> (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<rai::uint512_union *> (destination));
+	auto & number (*reinterpret_cast<nano::uint512_union *> (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<rai::uint256_union *> (seed));
-	rai::random_pool.GenerateBlock (number.bytes.data (), number.bytes.size ());
+	auto & number (*reinterpret_cast<nano::uint256_union *> (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<rai::uint256_union *> (seed));
-	auto & destination_l (*reinterpret_cast<rai::uint256_union *> (destination));
-	rai::deterministic_key (seed_l, index, destination_l);
+	auto & seed_l (*reinterpret_cast<nano::uint256_union *> (seed));
+	auto & destination_l (*reinterpret_cast<nano::uint256_union *> (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<rai::uint256_union *> (private_key);
-			block->signature_set (rai::sign_message (prv, pub, block->hash ()));
+			nano::raw_key prv;
+			prv.data = *reinterpret_cast<nano::uint256_union *> (private_key);
+			block->signature_set (nano::sign_message (prv, pub, block->hash ()));
 			auto json (block->to_json ());
 			result = reinterpret_cast<char *> (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 <ed25519-donna/ed25519-hash-custom.h>
 void ed25519_randombytes_unsafe (void * out, size_t outlen)
 {
-	rai::random_pool.GenerateBlock (reinterpret_cast<uint8_t *> (out), outlen);
+	nano::random_pool.GenerateBlock (reinterpret_cast<uint8_t *> (out), outlen);
 }
 void ed25519_hash_init (ed25519_hash_context * ctx)
 {

nano/lib/numbers.cpp

@@ -1,5 +1,5 @@
-#include <rai/lib/numbers.hpp>
-#include <rai/lib/utility.hpp>
+#include <nano/lib/numbers.hpp>
+#include <nano/lib/utility.hpp>
 
 #include <ed25519-donna/ed25519.h>
 
@@ -8,7 +8,7 @@
 #include <cryptopp/aes.h>
 #include <cryptopp/modes.h>
 
-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<uint8_t *> (&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<uint8_t> (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<rai::uint256_t> ();
+						*this = (number_l >> 40).convert_to<nano::uint256_t> ();
 						uint64_t check (number_l & static_cast<uint64_t> (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<uint8_t *> (&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::numpunct<char>> (std::locale ()).thousands_sep ();
 	auto decimal_point = std::use_facet<std::numpunct<char>> (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<std::moneypunct<char>> (locale).thousands_sep ();
 	auto decimal_point = std::use_facet<std::moneypunct<char>> (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);

nano/lib/numbers.hpp

@@ -4,21 +4,21 @@
 
 #include <cryptopp/osrng.h>
 
-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<uint8_t, 64> bytes;
@@ -120,33 +120,33 @@ union uint512_union
 	std::array<uint256_union, 2> 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<rai::uint256_union>
+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<size_t const *> (data_a.bytes.data ());
 	}
 };
 template <>
-struct hash<rai::uint256_t>
+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<size_t> ();
 	}

nano/lib/plat/darwin/thread_role.cpp

@@ -0,0 +1,7 @@
+#include <nano/lib/utility.hpp>
+#include <pthread.h>
+
+void nano::thread_role::set_name (std::string thread_name)
+{
+	pthread_setname_np (thread_name.c_str ());
+}

nano/lib/plat/default/priority.cpp

@@ -0,0 +1,5 @@
+#include <nano/lib/utility.hpp>
+
+void nano::work_thread_reprioritize ()
+{
+}

nano/lib/plat/freebsd/thread_role.cpp

@@ -1,8 +1,8 @@
+#include <nano/lib/utility.hpp>
 #include <pthread.h>
 #include <pthread_np.h>
-#include <rai/lib/utility.hpp>
 
-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 ());
 }

nano/lib/plat/linux/priority.cpp

@@ -1,8 +1,8 @@
-#include <rai/lib/utility.hpp>
+#include <nano/lib/utility.hpp>
 
 #include <pthread.h>
 
-void rai::work_thread_reprioritize ()
+void nano::work_thread_reprioritize ()
 {
 	auto handle (pthread_self ());
 	int policy;

nano/lib/plat/linux/thread_role.cpp

@@ -0,0 +1,7 @@
+#include <nano/lib/utility.hpp>
+#include <pthread.h>
+
+void nano::thread_role::set_name (std::string thread_name)
+{
+	pthread_setname_np (pthread_self (), thread_name.c_str ());
+}

nano/lib/plat/posix/perms.cpp

@@ -1,31 +1,31 @@
 #include <boost/filesystem.hpp>
 
-#include <rai/lib/utility.hpp>
+#include <nano/lib/utility.hpp>
 
 #include <sys/stat.h>
 #include <sys/types.h>
 
-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);
 }

nano/lib/plat/windows/perms.cpp

@@ -1,12 +1,12 @@
 #include <assert.h>
 #include <boost/filesystem.hpp>
-#include <rai/lib/utility.hpp>
+#include <nano/lib/utility.hpp>
 
 #include <io.h>
 #include <sys/stat.h>
 #include <sys/types.h>
 
-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);
 }

nano/lib/plat/windows/priority.cpp

@@ -1,8 +1,8 @@
-#include <rai/lib/utility.hpp>
+#include <nano/lib/utility.hpp>
 
 #include <windows.h>
 
-void rai::work_thread_reprioritize ()
+void nano::work_thread_reprioritize ()
 {
 	auto SUCCESS (SetThreadPriority (GetCurrentThread (), THREAD_MODE_BACKGROUND_BEGIN));
 }

nano/lib/plat/windows/thread_role.cpp

@@ -1,11 +1,11 @@
 #include <windows.h>
 
+#include <nano/lib/utility.hpp>
 #include <processthreadsapi.h>
-#include <rai/lib/utility.hpp>
 
 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;
 

nano/lib/utility.cpp

@@ -1,61 +1,61 @@
 #include <iostream>
-#include <rai/lib/utility.hpp>
+#include <nano/lib/utility.hpp>
 
-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 = "<unknown>";
 				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

nano/lib/utility.hpp

@@ -9,7 +9,7 @@
 #include <thread>
 #include <vector>
 
-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);
 }
 

nano/lib/work.cpp

@@ -1,26 +1,26 @@
-#include <rai/lib/work.hpp>
+#include <nano/lib/work.hpp>
 
-#include <rai/lib/blocks.hpp>
-#include <rai/node/xorshift.hpp>
+#include <nano/lib/blocks.hpp>
+#include <nano/node/xorshift.hpp>
 
 #include <future>
 
-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<boost::optional<uint64_t> (rai::uint256_union const &)> opencl_a) :
+nano::work_pool::work_pool (unsigned max_threads_a, std::function<boost::optional<uint64_t> (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<uint8_t *> (rng.s.data ()), rng.s.size () * sizeof (decltype (rng.s)::value_type));
+	nano::random_pool.GenerateBlock (reinterpret_cast<uint8_t *> (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<std::mutex> 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<std::mutex> 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<void(boost::optional<uint64_t> const &)> callback_a, uint64_t difficulty_a)
+void nano::work_pool::generate (nano::uint256_union const & root_a, std::function<void(boost::optional<uint64_t> const &)> callback_a, uint64_t difficulty_a)
 {
 	assert (!root_a.is_zero ());
 	boost::optional<uint64_t> 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<boost::optional<uint64_t>> work;
 	generate (hash_a, [&work](boost::optional<uint64_t> work_a) {

nano/lib/work.hpp

@@ -0,0 +1,51 @@
+#pragma once
+
+#include <boost/optional.hpp>
+#include <boost/thread/thread.hpp>
+#include <nano/lib/config.hpp>
+#include <nano/lib/numbers.hpp>
+#include <nano/lib/utility.hpp>
+
+#include <atomic>
+#include <condition_variable>
+#include <memory>
+#include <thread>
+
+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<void(boost::optional<uint64_t> const &)> callback;
+	uint64_t difficulty;
+};
+class work_pool
+{
+public:
+	work_pool (unsigned, std::function<boost::optional<uint64_t> (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<void(boost::optional<uint64_t> const &)>, uint64_t = nano::work_pool::publish_threshold);
+	uint64_t generate (nano::uint256_union const &, uint64_t = nano::work_pool::publish_threshold);
+	std::atomic<int> ticket;
+	bool done;
+	std::vector<boost::thread> threads;
+	std::list<nano::work_item> pending;
+	std::mutex mutex;
+	std::condition_variable producer_condition;
+	std::function<boost::optional<uint64_t> (nano::uint256_union const &)> opencl;
+	nano::observer_set<bool> 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;
+};
+}

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()

nano/nano_node/daemon.cpp

@@ -1,18 +1,18 @@
-#include <rai/lib/utility.hpp>
-#include <rai/rai_node/daemon.hpp>
+#include <nano/lib/utility.hpp>
+#include <nano/nano_node/daemon.hpp>
 
 #include <boost/property_tree/json_parser.hpp>
 #include <fstream>
 #include <iostream>
-#include <rai/node/working.hpp>
+#include <nano/node/working.hpp>
 
-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<rai::thread_runner> runner;
-	auto error (rai::fetch_object (config, config_path, config_file));
-	rai::set_secure_perm_file (config_path, error_chmod);
+	std::unique_ptr<nano::thread_runner> 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<boost::optional<uint64_t> (rai::uint256_union const &)> (nullptr));
-		rai::alarm alarm (io_ctx);
-		rai::node_init init;
+		                                                              : std::function<boost::optional<uint64_t> (nano::uint256_union const &)> (nullptr));
+		nano::alarm alarm (io_ctx);
+		nano::node_init init;
 		try
 		{
-			auto node (std::make_shared<rai::node> (init, io_ctx, data_path, alarm, config.node, opencl_work));
+			auto node (std::make_shared<nano::node> (init, io_ctx, data_path, alarm, config.node, opencl_work));
 			if (!init.error ())
 			{
 				node->flags = flags;
 				node->start ();
-				std::unique_ptr<rai::rpc> rpc = get_rpc (io_ctx, *node, config.rpc);
+				std::unique_ptr<nano::rpc> rpc = get_rpc (io_ctx, *node, config.rpc);
 				if (rpc && config.rpc_enable)
 				{
 					rpc->start ();
 				}
-				runner = std::make_unique<rai::thread_runner> (io_ctx, node->config.io_threads);
+				runner = std::make_unique<nano::thread_runner> (io_ctx, node->config.io_threads);
 				runner->join ();
 			}
 			else

nano/nano_node/daemon.hpp

@@ -1,12 +1,12 @@
-#include <rai/node/node.hpp>
-#include <rai/node/rpc.hpp>
+#include <nano/node/node.hpp>
+#include <nano/node/rpc.hpp>
 
-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;
 };
 }

nano/nano_node/entry.cpp

@@ -1,8 +1,8 @@
-#include <rai/lib/utility.hpp>
-#include <rai/node/cli.hpp>
-#include <rai/node/node.hpp>
-#include <rai/node/testing.hpp>
-#include <rai/rai_node/daemon.hpp>
+#include <nano/lib/utility.hpp>
+#include <nano/nano_node/daemon.hpp>
+#include <nano/node/cli.hpp>
+#include <nano/node/node.hpp>
+#include <nano/node/testing.hpp>
 
 #include <argon2.h>
 
@@ -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<std::string> (), "Defines the <platform> for OpenCL commands")
 		("device", boost::program_options::value<std::string> (), "Defines <device> 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<std::string> ()) : 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<std::string> ()) : 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<std::string> ()))
 				{
-					rai::keypair genesis (key.to_string ());
-					rai::work_pool work (std::numeric_limits<unsigned>::max (), nullptr);
+					nano::keypair genesis (key.to_string ());
+					nano::work_pool work (std::numeric_limits<unsigned>::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<rai::uint128_t>::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<nano::uint128_t>::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<std::string> () % total.convert_to<std::string> ());
 			}
-			std::map<rai::account, rai::uint128_t> calculated;
+			std::map<nano::account, nano::uint128_t> 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<std::chrono::microseconds> (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<unsigned>::max (), nullptr);
-			rai::change_block block (0, 0, rai::keypair ().prv, 0, 0);
+			nano::work_pool work (std::numeric_limits<unsigned>::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<unsigned>::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<unsigned>::max (), opencl ? [&opencl](nano::uint256_union const & root_a) {
 								return opencl->generate_work (root_a);
 							}
-							                                                                        : std::function<boost::optional<uint64_t> (rai::uint256_union const &)> (nullptr));
-							rai::change_block block (0, 0, rai::keypair ().prv, 0, 0);
+							                                                                         : std::function<boost::optional<uint64_t> (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<unsigned>::max (), nullptr);
-			rai::change_block block (0, 0, rai::keypair ().prv, 0, 0);
+			nano::work_pool work (std::numeric_limits<unsigned>::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<std::chrono::microseconds> (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<std::chrono::microseconds> (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<unsigned char const *> messages (batch_count, message.bytes.data ());
 			std::vector<size_t> lengths (batch_count, sizeof (message));
 			std::vector<unsigned char const *> pub_keys (batch_count, key.pub.bytes.data ());
@@ -337,7 +337,7 @@ int main (int argc, char * const * argv)
 			std::vector<int> 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<std::chrono::microseconds> (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<unsigned>::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<unsigned>::max (), nullptr);
+				nano::logging logging;
+				auto path (nano::unique_path ());
 				logging.init (path);
-				auto node (std::make_shared<rai::node> (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<rai::uint128_t>::max ());
+				auto node (std::make_shared<nano::node> (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<nano::uint128_t>::max ());
 				// Generating keys
-				std::vector<rai::keypair> keys (num_accounts);
-				std::vector<rai::block_hash> frontiers (num_accounts);
-				std::vector<rai::uint128_t> balances (num_accounts, 1000000000);
+				std::vector<nano::keypair> keys (num_accounts);
+				std::vector<nano::block_hash> frontiers (num_accounts);
+				std::vector<nano::uint128_t> balances (num_accounts, 1000000000);
 				// Generating blocks
-				std::deque<std::shared_ptr<rai::block>> blocks;
+				std::deque<std::shared_ptr<nano::block>> blocks;
 				for (auto i (0); i != num_accounts; ++i)
 				{
 					genesis_balance = genesis_balance - 1000000000;
-					auto send (std::make_shared<rai::state_block> (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::state_block> (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<rai::state_block> (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<nano::state_block> (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<rai::state_block> (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<nano::state_block> (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<rai::state_block> (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<nano::state_block> (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<unsigned>::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<unsigned>::max (), nullptr);
+				nano::logging logging;
+				auto path (nano::unique_path ());
 				logging.init (path);
-				auto node (std::make_shared<rai::node> (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<rai::uint128_t>::max ());
+				auto node (std::make_shared<nano::node> (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<nano::uint128_t>::max ());
 				// Generating keys
-				std::vector<rai::keypair> keys (num_representatives);
-				rai::uint128_t balance ((node->config.online_weight_minimum.number () / num_representatives) + 1);
+				std::vector<nano::keypair> 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<std::shared_ptr<rai::block>> blocks;
+				std::deque<std::shared_ptr<nano::block>> blocks;
 				for (auto i (0); i != num_elections; ++i)
 				{
 					genesis_balance = genesis_balance - 1;
-					rai::keypair destination;
-					auto send (std::make_shared<rai::state_block> (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::state_block> (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<std::shared_ptr<rai::vote>> votes;
+				std::deque<std::shared_ptr<nano::vote>> votes;
 				for (auto j (0); j != num_representatives; ++j)
 				{
 					uint64_t sequence (1);
 					for (auto & i : blocks)
 					{
-						auto vote (std::make_shared<rai::vote> (keys[j].pub, keys[j].prv, sequence, std::vector<rai::block_hash> (1, i->hash ())));
+						auto vote (std::make_shared<nano::vote> (keys[j].pub, keys[j].prv, sequence, std::vector<nano::block_hash> (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<rai::state_block const &> (*block.get ()).hashables.account != account))
+					if ((block->type () == nano::block_type::open && block->root () != account) || (block->type () == nano::block_type::state && static_cast<nano::state_block const &> (*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<rai::state_block &> (*block.get ()));
-							rai::amount prev_balance (0);
+							auto & state_block (static_cast<nano::state_block &> (*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<rai::state_block *> (block.get ()))
+					nano::account destination (0);
+					if (auto state = dynamic_cast<nano::state_block *> (block.get ()))
 					{
 						if (node.node->ledger.is_send (transaction, *state))
 						{
 							destination = state->hashables.link;
 						}
 					}
-					else if (auto send = dynamic_cast<rai::send_block *> (block.get ()))
+					else if (auto send = dynamic_cast<nano::send_block *> (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<std::chrono::microseconds> (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
 		{

nano/nano_wallet/entry.cpp

@@ -1,9 +1,9 @@
-#include <rai/lib/utility.hpp>
-#include <rai/node/cli.hpp>
-#include <rai/node/rpc.hpp>
-#include <rai/node/working.hpp>
-#include <rai/qt/qt.hpp>
-#include <rai/rai_wallet/icon.hpp>
+#include <nano/lib/utility.hpp>
+#include <nano/nano_wallet/icon.hpp>
+#include <nano/node/cli.hpp>
+#include <nano/node/rpc.hpp>
+#include <nano/node/working.hpp>
+#include <nano/qt/qt.hpp>
 
 #include <boost/make_shared.hpp>
 #include <boost/program_options.hpp>
@@ -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<std::string> ("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<rai::node> node;
-		std::shared_ptr<rai_qt::wallet> 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<nano::node> node;
+		std::shared_ptr<nano_qt::wallet> 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<boost::optional<uint64_t> (rai::uint256_union const &)> (nullptr));
-		rai::alarm alarm (io_ctx);
-		rai::node_init init;
-		node = std::make_shared<rai::node> (init, io_ctx, data_path, alarm, config.node, work);
+		                                                       : std::function<boost::optional<uint64_t> (nano::uint256_union const &)> (nullptr));
+		nano::alarm alarm (io_ctx);
+		nano::node_init init;
+		node = std::make_shared<nano::node> (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<rai::rpc> rpc = get_rpc (io_ctx, *node, config.rpc);
+			std::unique_ptr<nano::rpc> 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<rai_qt::wallet> (application, processor, *node, wallet, config.account);
+			application.postEvent (&processor, new nano_qt::eventloop_event ([&]() {
+				gui = std::make_shared<nano_qt::wallet> (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<char **> (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);

nano/nano_wallet/icon.hpp

@@ -1,7 +1,7 @@
 #pragma once
 
 class QApplication;
-namespace rai
+namespace nano
 {
 void set_application_icon (QApplication &);
 }

nano/nano_wallet/plat/default/icon.cpp

@@ -0,0 +1,5 @@
+#include <nano/nano_wallet/icon.hpp>
+
+void nano::set_application_icon (QApplication &)
+{
+}

nano/nano_wallet/plat/windows/icon.cpp

@@ -1,10 +1,10 @@
-#include <rai/rai_wallet/icon.hpp>
+#include <nano/nano_wallet/icon.hpp>
 
 #include <QApplication>
 #include <QtGui>
 #include <QtWin>
 
-void rai::set_application_icon (QApplication & application_a)
+void nano::set_application_icon (QApplication & application_a)
 {
 	HICON hIcon = static_cast<HICON> (LoadImage (GetModuleHandle (nullptr), MAKEINTRESOURCE (1), IMAGE_ICON, 0, 0, LR_DEFAULTSIZE | LR_LOADTRANSPARENT));
 	application_a.setWindowIcon (QIcon (QtWin::fromHICON (hIcon)));

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})

nano/node/bootstrap.hpp

@@ -0,0 +1,341 @@
+#pragma once
+
+#include <nano/node/common.hpp>
+#include <nano/secure/blockstore.hpp>
+#include <nano/secure/ledger.hpp>
+
+#include <atomic>
+#include <future>
+#include <queue>
+#include <stack>
+#include <unordered_set>
+
+#include <boost/log/sources/logger.hpp>
+#include <boost/thread/thread.hpp>
+
+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<nano::socket>
+{
+public:
+	socket (std::shared_ptr<nano::node>);
+	void async_connect (nano::tcp_endpoint const &, std::function<void(boost::system::error_code const &)>);
+	void async_read (std::shared_ptr<std::vector<uint8_t>>, size_t, std::function<void(boost::system::error_code const &, size_t)>);
+	void async_write (std::shared_ptr<std::vector<uint8_t>>, std::function<void(boost::system::error_code const &, size_t)>);
+	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<uint64_t> cutoff;
+	std::shared_ptr<nano::node> 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<bootstrap_attempt>
+{
+public:
+	bootstrap_attempt (std::shared_ptr<nano::node> node_a);
+	~bootstrap_attempt ();
+	void run ();
+	std::shared_ptr<nano::bootstrap_client> connection (std::unique_lock<std::mutex> &);
+	bool consume_future (std::future<bool> &);
+	void populate_connections ();
+	bool request_frontier (std::unique_lock<std::mutex> &);
+	void request_pull (std::unique_lock<std::mutex> &);
+	void request_push (std::unique_lock<std::mutex> &);
+	void add_connection (nano::endpoint const &);
+	void pool_connection (std::shared_ptr<nano::bootstrap_client>);
+	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<nano::block>, 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<std::weak_ptr<nano::bootstrap_client>> clients;
+	std::weak_ptr<nano::bootstrap_client> connection_frontier_request;
+	std::weak_ptr<nano::frontier_req_client> frontiers;
+	std::weak_ptr<nano::bulk_push_client> push;
+	std::deque<nano::pull_info> pulls;
+	std::deque<std::shared_ptr<nano::bootstrap_client>> idle;
+	std::atomic<unsigned> connections;
+	std::atomic<unsigned> pulling;
+	std::shared_ptr<nano::node> node;
+	std::atomic<unsigned> account_count;
+	std::atomic<uint64_t> total_blocks;
+	std::vector<std::pair<nano::block_hash, nano::block_hash>> bulk_push_targets;
+	bool stopped;
+	bool lazy_mode;
+	std::mutex mutex;
+	std::condition_variable condition;
+	// Lazy bootstrap
+	std::unordered_set<nano::block_hash> lazy_blocks;
+	std::unordered_map<nano::block_hash, std::pair<nano::block_hash, nano::uint128_t>> lazy_state_unknown;
+	std::unordered_map<nano::block_hash, nano::uint128_t> lazy_balances;
+	std::unordered_set<nano::block_hash> lazy_keys;
+	std::deque<nano::block_hash> lazy_pulls;
+	std::atomic<uint64_t> 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<nano::frontier_req_client>
+{
+public:
+	frontier_req_client (std::shared_ptr<nano::bootstrap_client>);
+	~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<nano::bootstrap_client> 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<bool> promise;
+	/** A very rough estimate of the cost of `bulk_push`ing missing blocks */
+	uint64_t bulk_push_cost;
+	std::deque<std::pair<nano::account, nano::block_hash>> accounts;
+};
+class bulk_pull_client : public std::enable_shared_from_this<nano::bulk_pull_client>
+{
+public:
+	bulk_pull_client (std::shared_ptr<nano::bootstrap_client>, 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<nano::bootstrap_client> connection;
+	nano::block_hash expected;
+	nano::pull_info pull;
+	uint64_t total_blocks;
+};
+class bootstrap_client : public std::enable_shared_from_this<bootstrap_client>
+{
+public:
+	bootstrap_client (std::shared_ptr<nano::node>, std::shared_ptr<nano::bootstrap_attempt>, nano::tcp_endpoint const &);
+	~bootstrap_client ();
+	void run ();
+	std::shared_ptr<nano::bootstrap_client> shared ();
+	void stop (bool force);
+	double block_rate () const;
+	double elapsed_seconds () const;
+	std::shared_ptr<nano::node> node;
+	std::shared_ptr<nano::bootstrap_attempt> attempt;
+	std::shared_ptr<nano::socket> socket;
+	std::shared_ptr<std::vector<uint8_t>> receive_buffer;
+	nano::tcp_endpoint endpoint;
+	std::chrono::steady_clock::time_point start_time;
+	std::atomic<uint64_t> block_count;
+	std::atomic<bool> pending_stop;
+	std::atomic<bool> hard_stop;
+};
+class bulk_push_client : public std::enable_shared_from_this<nano::bulk_push_client>
+{
+public:
+	bulk_push_client (std::shared_ptr<nano::bootstrap_client> const &);
+	~bulk_push_client ();
+	void start ();
+	void push (nano::transaction const &);
+	void push_block (nano::block const &);
+	void send_finished ();
+	std::shared_ptr<nano::bootstrap_client> connection;
+	std::promise<bool> promise;
+	std::pair<nano::block_hash, nano::block_hash> 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<void(bool)> const &);
+	bool in_progress ();
+	std::shared_ptr<nano::bootstrap_attempt> current_attempt ();
+	void stop ();
+
+private:
+	nano::node & node;
+	std::shared_ptr<nano::bootstrap_attempt> attempt;
+	bool stopped;
+	std::mutex mutex;
+	std::condition_variable condition;
+	std::vector<std::function<void(bool)>> 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<nano::socket>);
+	std::mutex mutex;
+	std::unordered_map<nano::bootstrap_server *, std::weak_ptr<nano::bootstrap_server>> 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<nano::bootstrap_server>
+{
+public:
+	bootstrap_server (std::shared_ptr<nano::socket>, std::shared_ptr<nano::node>);
+	~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<nano::message>);
+	void finish_request ();
+	void run_next ();
+	std::shared_ptr<std::vector<uint8_t>> receive_buffer;
+	std::shared_ptr<nano::socket> socket;
+	std::shared_ptr<nano::node> node;
+	std::mutex mutex;
+	std::queue<std::unique_ptr<nano::message>> requests;
+};
+class bulk_pull;
+class bulk_pull_server : public std::enable_shared_from_this<nano::bulk_pull_server>
+{
+public:
+	bulk_pull_server (std::shared_ptr<nano::bootstrap_server> const &, std::unique_ptr<nano::bulk_pull>);
+	void set_current_end ();
+	std::shared_ptr<nano::block> 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<nano::bootstrap_server> connection;
+	std::unique_ptr<nano::bulk_pull> request;
+	std::shared_ptr<std::vector<uint8_t>> 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<nano::bulk_pull_account_server>
+{
+public:
+	bulk_pull_account_server (std::shared_ptr<nano::bootstrap_server> const &, std::unique_ptr<nano::bulk_pull_account>);
+	void set_params ();
+	std::pair<std::unique_ptr<nano::pending_key>, std::unique_ptr<nano::pending_info>> 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<nano::bootstrap_server> connection;
+	std::unique_ptr<nano::bulk_pull_account> request;
+	std::shared_ptr<std::vector<uint8_t>> send_buffer;
+	std::unordered_map<nano::uint256_union, bool> 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<nano::bulk_pull_blocks_server>
+{
+public:
+	bulk_pull_blocks_server (std::shared_ptr<nano::bootstrap_server> const &, std::unique_ptr<nano::bulk_pull_blocks>);
+	void set_params ();
+	std::shared_ptr<nano::block> get_next ();
+	void send_next ();
+	void send_finished ();
+	void no_block_sent (boost::system::error_code const &, size_t);
+	std::shared_ptr<nano::bootstrap_server> connection;
+	std::unique_ptr<nano::bulk_pull_blocks> request;
+	std::shared_ptr<std::vector<uint8_t>> send_buffer;
+};
+class bulk_push_server : public std::enable_shared_from_this<nano::bulk_push_server>
+{
+public:
+	bulk_push_server (std::shared_ptr<nano::bootstrap_server> 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<std::vector<uint8_t>> receive_buffer;
+	std::shared_ptr<nano::bootstrap_server> connection;
+};
+class frontier_req;
+class frontier_req_server : public std::enable_shared_from_this<nano::frontier_req_server>
+{
+public:
+	frontier_req_server (std::shared_ptr<nano::bootstrap_server> const &, std::unique_ptr<nano::frontier_req>);
+	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<nano::bootstrap_server> connection;
+	nano::account current;
+	nano::block_hash frontier;
+	std::unique_ptr<nano::frontier_req> request;
+	std::shared_ptr<std::vector<uint8_t>> send_buffer;
+	size_t count;
+	std::deque<std::pair<nano::account, nano::block_hash>> accounts;
+};
+}

nano/node/cli.cpp

@@ -1,26 +1,26 @@
-#include <rai/lib/interface.h>
-#include <rai/node/cli.hpp>
-#include <rai/node/common.hpp>
-#include <rai/node/node.hpp>
+#include <nano/lib/interface.h>
+#include <nano/node/cli.hpp>
+#include <nano/node/common.hpp>
+#include <nano/node/node.hpp>
 
-std::string rai::error_cli_messages::message (int ev) const
+std::string nano::error_cli_messages::message (int ev) const
 {
-	switch (static_cast<rai::error_cli> (ev))
+	switch (static_cast<nano::error_cli> (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<std::string> ()) : rai::working_path ();
+	boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as<std::string> ()) : 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> ()))
 			{
 				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 <wallet> option and one <key> option and optionally one <password> 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::string> ());
 			std::cout << "Account: " << pub.to_account () << std::endl;
 		}
 		else
 		{
 			std::cerr << "account comand requires one <key> 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::string> ());
 			std::cout << "Hex: " << account.to_string () << std::endl;
 		}
 		else
 		{
 			std::cerr << "account_key command requires one <account> 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<std::string> ()) : rai::working_path ();
+			boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as<std::string> ()) : 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<std::string> ()) : rai::working_path ();
+		boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as<std::string> ()) : 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<std::string> ()) : rai::working_path ();
+		boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as<std::string> ()) : 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<std::string> ()) : rai::working_path ();
+		boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as<std::string> ()) : 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<std::string> ());
-			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 <key> 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> ()))
 			{
 				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<std::string> ()))
 						{
 							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 <wallet> option and one <key> option and optionally one <password> 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> ()))
 			{
 				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<std::string> ()))
 						{
 							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 <wallet> option and one <key> option and optionally one <password> 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<std::string> ();
 			}
-			rai::uint256_union wallet_id;
+			nano::uint256_union wallet_id;
 			if (!wallet_id.decode_hex (vm["wallet"].as<std::string> ()))
 			{
 				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 <wallet> 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<std::string> ()))
 			{
 				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 <wallet> 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<std::string> ()))
 					{
 						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 <wallet> option\n";
-					ec = rai::error_cli::invalid_arguments;
+					ec = nano::error_cli::invalid_arguments;
 				}
 			}
 			else
 			{
 				std::cerr << "Unable to open <file>\n";
-				ec = rai::error_cli::invalid_arguments;
+				ec = nano::error_cli::invalid_arguments;
 			}
 		}
 		else
 		{
 			std::cerr << "wallet_import requires one <file> 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<std::string> ()))
 			{
 				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<std::string> ()))
 					{
 						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 <wallet> and one <account> 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<std::string> ()))
 			{
 				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 <wallet> 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<std::string> ()))
 				{
-					rai::account account;
+					nano::account account;
 					if (!account.decode_account (vm["account"].as<std::string> ()))
 					{
 						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 <account> option\n";
-				ec = rai::error_cli::invalid_arguments;
+				ec = nano::error_cli::invalid_arguments;
 			}
 		}
 		else
 		{
 			std::cerr << "wallet_representative_set requires one <wallet> 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;

nano/node/cli.hpp

@@ -1,9 +1,9 @@
 #pragma once
 
 #include <boost/program_options.hpp>
-#include <rai/lib/errors.hpp>
+#include <nano/lib/errors.hpp>
 
-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)

nano/node/common.cpp

@@ -0,0 +1,974 @@
+
+#include <nano/node/common.hpp>
+
+#include <nano/lib/work.hpp>
+#include <nano/node/wallet.hpp>
+
+#include <boost/endian/conversion.hpp>
+
+std::array<uint8_t, 2> 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<uint16_t> (extensions.to_ullong ()));
+}
+
+bool nano::message_header::deserialize (nano::stream & stream_a)
+{
+	uint16_t extensions_l;
+	std::array<uint8_t, 2> 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<nano::block_type> (((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<unsigned long long> (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<std::shared_ptr<nano::block>> (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<uint8_t, 16> 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<nano::block> 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<nano::block> 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<nano::vote> (error_a, stream_a, header.block_type ()))
+{
+	if (uniquer_a)
+	{
+		vote = uniquer_a->unique (vote);
+	}
+}
+
+nano::confirm_ack::confirm_ack (std::shared_ptr<nano::vote> 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<std::shared_ptr<nano::block>> (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<uint8_t, extended_parameters_size> 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<uint8_t, extended_parameters_size> 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<nano::uint256_union> query, boost::optional<std::pair<nano::account, nano::signature>> 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<uint16_t>::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;
+}

nano/node/common.hpp

@@ -0,0 +1,398 @@
+#pragma once
+
+#include <nano/lib/interface.h>
+#include <nano/secure/common.hpp>
+
+#include <boost/asio.hpp>
+
+#include <bitset>
+
+#include <xxhash/xxhash.h>
+
+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 <size_t size>
+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<uint32_t> (big) ^ static_cast<uint32_t> (big >> 32));
+		return result;
+	}
+};
+}
+
+namespace std
+{
+template <>
+struct hash<::nano::endpoint>
+{
+	size_t operator() (::nano::endpoint const & endpoint_a) const
+	{
+		endpoint_hash<sizeof (size_t)> ehash;
+		return ehash (endpoint_a);
+	}
+};
+template <size_t size>
+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<uint32_t> (big) ^ static_cast<uint32_t> (big >> 32));
+		return result;
+	}
+};
+template <>
+struct hash<boost::asio::ip::address>
+{
+	size_t operator() (boost::asio::ip::address const & ip_a) const
+	{
+		ip_address_hash<sizeof (size_t)> 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<uint8_t, 2> constexpr magic_number = nano::nano_network == nano::nano_networks::nano_test_network ? std::array<uint8_t, 2>{ { 'R', 'A' } } : nano::nano_network == nano::nano_networks::nano_beta_network ? std::array<uint8_t, 2>{ { 'R', 'B' } } : std::array<uint8_t, 2>{ { '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<int> (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<std::vector<uint8_t>> to_bytes () const
+	{
+		std::shared_ptr<std::vector<uint8_t>> bytes (new std::vector<uint8_t>);
+		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<nano::endpoint, 8> peers;
+};
+class publish : public message
+{
+public:
+	publish (bool &, nano::stream &, nano::message_header const &, nano::block_uniquer * = nullptr);
+	publish (std::shared_ptr<nano::block>);
+	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<nano::block> 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<nano::block>);
+	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<nano::block> 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<nano::vote>);
+	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<nano::vote> 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<nano::block_hash>, boost::optional<std::pair<nano::account, nano::signature>>);
+	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<nano::uint256_union> query;
+	boost::optional<std::pair<nano::account, nano::signature>> 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::seconds> (std::chrono::system_clock::now ().time_since_epoch ()).count ();
+}
+}

nano/node/lmdb.hpp

@@ -0,0 +1,389 @@
+#pragma once
+
+#include <boost/filesystem.hpp>
+
+#include <lmdb/libraries/liblmdb/lmdb.h>
+
+#include <nano/lib/numbers.hpp>
+#include <nano/secure/blockstore.hpp>
+#include <nano/secure/common.hpp>
+
+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<nano::block> const &);
+	mdb_val (std::shared_ptr<nano::vote> 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<char, 64> () const;
+	explicit operator no_value () const;
+	explicit operator std::shared_ptr<nano::block> () const;
+	explicit operator std::shared_ptr<nano::send_block> () const;
+	explicit operator std::shared_ptr<nano::receive_block> () const;
+	explicit operator std::shared_ptr<nano::open_block> () const;
+	explicit operator std::shared_ptr<nano::change_block> () const;
+	explicit operator std::shared_ptr<nano::state_block> () const;
+	explicit operator std::shared_ptr<nano::vote> () const;
+	explicit operator uint64_t () const;
+	operator MDB_val * () const;
+	operator MDB_val const & () const;
+	MDB_val value;
+	std::shared_ptr<std::vector<uint8_t>> buffer;
+	nano::epoch epoch{ nano::epoch::unspecified };
+};
+class block_store;
+
+template <typename T, typename U>
+class mdb_iterator : public store_iterator_impl<T, U>
+{
+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<T, U> && other_a);
+	mdb_iterator (nano::mdb_iterator<T, U> const &) = delete;
+	~mdb_iterator ();
+	nano::store_iterator_impl<T, U> & operator++ () override;
+	std::pair<nano::mdb_val, nano::mdb_val> * operator-> ();
+	bool operator== (nano::store_iterator_impl<T, U> const & other_a) const override;
+	bool is_end_sentinal () const override;
+	void fill (std::pair<T, U> &) const override;
+	void clear ();
+	nano::mdb_iterator<T, U> & operator= (nano::mdb_iterator<T, U> && other_a);
+	nano::store_iterator_impl<T, U> & operator= (nano::store_iterator_impl<T, U> const &) = delete;
+	MDB_cursor * cursor;
+	std::pair<nano::mdb_val, nano::mdb_val> current;
+
+private:
+	MDB_txn * tx (nano::transaction const &) const;
+};
+
+/**
+ * Iterates the key/value pairs of two stores merged together
+ */
+template <typename T, typename U>
+class mdb_merge_iterator : public store_iterator_impl<T, U>
+{
+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<T, U> &&);
+	mdb_merge_iterator (nano::mdb_merge_iterator<T, U> const &) = delete;
+	~mdb_merge_iterator ();
+	nano::store_iterator_impl<T, U> & operator++ () override;
+	std::pair<nano::mdb_val, nano::mdb_val> * operator-> ();
+	bool operator== (nano::store_iterator_impl<T, U> const &) const override;
+	bool is_end_sentinal () const override;
+	void fill (std::pair<T, U> &) const override;
+	void clear ();
+	nano::mdb_merge_iterator<T, U> & operator= (nano::mdb_merge_iterator<T, U> &&) = default;
+	nano::mdb_merge_iterator<T, U> & operator= (nano::mdb_merge_iterator<T, U> const &) = delete;
+
+private:
+	nano::mdb_iterator<T, U> & least_iterator () const;
+	std::unique_ptr<nano::mdb_iterator<T, U>> impl1;
+	std::unique_ptr<nano::mdb_iterator<T, U>> 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<nano::block> block_get (nano::transaction const &, nano::block_hash const &) override;
+	std::shared_ptr<nano::block> 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<nano::account, nano::account_info> latest_v0_begin (nano::transaction const &, nano::account const &) override;
+	nano::store_iterator<nano::account, nano::account_info> latest_v0_begin (nano::transaction const &) override;
+	nano::store_iterator<nano::account, nano::account_info> latest_v0_end () override;
+	nano::store_iterator<nano::account, nano::account_info> latest_v1_begin (nano::transaction const &, nano::account const &) override;
+	nano::store_iterator<nano::account, nano::account_info> latest_v1_begin (nano::transaction const &) override;
+	nano::store_iterator<nano::account, nano::account_info> latest_v1_end () override;
+	nano::store_iterator<nano::account, nano::account_info> latest_begin (nano::transaction const &, nano::account const &) override;
+	nano::store_iterator<nano::account, nano::account_info> latest_begin (nano::transaction const &) override;
+	nano::store_iterator<nano::account, nano::account_info> 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<nano::pending_key, nano::pending_info> pending_v0_begin (nano::transaction const &, nano::pending_key const &) override;
+	nano::store_iterator<nano::pending_key, nano::pending_info> pending_v0_begin (nano::transaction const &) override;
+	nano::store_iterator<nano::pending_key, nano::pending_info> pending_v0_end () override;
+	nano::store_iterator<nano::pending_key, nano::pending_info> pending_v1_begin (nano::transaction const &, nano::pending_key const &) override;
+	nano::store_iterator<nano::pending_key, nano::pending_info> pending_v1_begin (nano::transaction const &) override;
+	nano::store_iterator<nano::pending_key, nano::pending_info> pending_v1_end () override;
+	nano::store_iterator<nano::pending_key, nano::pending_info> pending_begin (nano::transaction const &, nano::pending_key const &) override;
+	nano::store_iterator<nano::pending_key, nano::pending_info> pending_begin (nano::transaction const &) override;
+	nano::store_iterator<nano::pending_key, nano::pending_info> 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<nano::block_hash, nano::block_info> block_info_begin (nano::transaction const &, nano::block_hash const &) override;
+	nano::store_iterator<nano::block_hash, nano::block_info> block_info_begin (nano::transaction const &) override;
+	nano::store_iterator<nano::block_hash, nano::block_info> 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<nano::account, nano::uint128_union> representation_begin (nano::transaction const &) override;
+	nano::store_iterator<nano::account, nano::uint128_union> representation_end () override;
+
+	void unchecked_clear (nano::transaction const &) override;
+	void unchecked_put (nano::transaction const &, nano::unchecked_key const &, std::shared_ptr<nano::block> const &) override;
+	void unchecked_put (nano::transaction const &, nano::block_hash const &, std::shared_ptr<nano::block> const &) override;
+	std::vector<std::shared_ptr<nano::block>> 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<nano::unchecked_key, std::shared_ptr<nano::block>> unchecked_begin (nano::transaction const &) override;
+	nano::store_iterator<nano::unchecked_key, std::shared_ptr<nano::block>> unchecked_begin (nano::transaction const &, nano::unchecked_key const &) override;
+	nano::store_iterator<nano::unchecked_key, std::shared_ptr<nano::block>> 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<nano::vote> vote_get (nano::transaction const &, nano::account const &) override;
+	// Populate vote with the next sequence number
+	std::shared_ptr<nano::vote> vote_generate (nano::transaction const &, nano::account const &, nano::raw_key const &, std::shared_ptr<nano::block>) override;
+	std::shared_ptr<nano::vote> vote_generate (nano::transaction const &, nano::account const &, nano::raw_key const &, std::vector<nano::block_hash>) override;
+	// Return either vote or the stored vote with a higher sequence number
+	std::shared_ptr<nano::vote> vote_max (nano::transaction const &, std::shared_ptr<nano::vote>) override;
+	// Return latest vote for an account considering the vote cache
+	std::shared_ptr<nano::vote> vote_current (nano::transaction const &, nano::account const &) override;
+	void flush (nano::transaction const &) override;
+	nano::store_iterator<nano::account, std::shared_ptr<nano::vote>> vote_begin (nano::transaction const &) override;
+	nano::store_iterator<nano::account, std::shared_ptr<nano::vote>> vote_end () override;
+	std::mutex cache_mutex;
+	std::unordered_map<nano::account, std::shared_ptr<nano::vote>> vote_cache_l1;
+	std::unordered_map<nano::account, std::shared_ptr<nano::vote>> 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 <typename T>
+	std::shared_ptr<nano::block> 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;
+};
+}

nano/node/logging.cpp

@@ -2,9 +2,9 @@
 #include <boost/log/utility/setup/common_attributes.hpp>
 #include <boost/log/utility/setup/console.hpp>
 #include <boost/log/utility/setup/file.hpp>
-#include <rai/node/logging.hpp>
+#include <nano/node/logging.hpp>
 
-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;
 }

nano/node/logging.hpp

@@ -8,7 +8,7 @@
 
 #define FATAL_LOG_PREFIX "FATAL ERROR: "
 
-namespace rai
+namespace nano
 {
 class logging
 {

nano/node/node.hpp

@@ -0,0 +1,553 @@
+#pragma once
+
+#include <nano/lib/work.hpp>
+#include <nano/node/bootstrap.hpp>
+#include <nano/node/logging.hpp>
+#include <nano/node/nodeconfig.hpp>
+#include <nano/node/peers.hpp>
+#include <nano/node/portmapping.hpp>
+#include <nano/node/stats.hpp>
+#include <nano/node/voting.hpp>
+#include <nano/node/wallet.hpp>
+#include <nano/secure/ledger.hpp>
+
+#include <condition_variable>
+
+#include <boost/iostreams/device/array.hpp>
+#include <boost/multi_index/hashed_index.hpp>
+#include <boost/multi_index/member.hpp>
+#include <boost/multi_index/ordered_index.hpp>
+#include <boost/multi_index/random_access_index.hpp>
+#include <boost/multi_index_container.hpp>
+#include <boost/thread/thread.hpp>
+
+namespace nano
+{
+class node;
+class election_status
+{
+public:
+	std::shared_ptr<nano::block> 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<nano::election>
+{
+	std::function<void(std::shared_ptr<nano::block>)> confirmation_action;
+	void confirm_once (nano::transaction const &);
+	void confirm_back (nano::transaction const &);
+
+public:
+	election (nano::node &, std::shared_ptr<nano::block>, std::function<void(std::shared_ptr<nano::block>)> 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<nano::block> block_a);
+	void stop ();
+	nano::node & node;
+	std::unordered_map<nano::account, nano::vote_info> last_votes;
+	std::unordered_map<nano::block_hash, std::shared_ptr<nano::block>> blocks;
+	nano::block_hash root;
+	std::chrono::steady_clock::time_point election_start;
+	nano::election_status status;
+	std::atomic<bool> confirmed;
+	bool stopped;
+	std::unordered_map<nano::block_hash, nano::uint128_t> last_tally;
+	unsigned announcements;
+};
+class conflict_info
+{
+public:
+	nano::block_hash root;
+	uint64_t difficulty;
+	std::shared_ptr<nano::election> 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<nano::block>, std::function<void(std::shared_ptr<nano::block>)> const & = [](std::shared_ptr<nano::block>) {});
+	// 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<nano::vote>, 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<std::shared_ptr<nano::block>> list_blocks (bool = false);
+	void erase (nano::block const &);
+	void stop ();
+	bool publish (std::shared_ptr<nano::block> block_a);
+	boost::multi_index_container<
+	nano::conflict_info,
+	boost::multi_index::indexed_by<
+	boost::multi_index::hashed_unique<
+	boost::multi_index::member<nano::conflict_info, nano::block_hash, &nano::conflict_info::root>>,
+	boost::multi_index::ordered_non_unique<
+	boost::multi_index::member<nano::conflict_info, uint64_t, &nano::conflict_info::difficulty>,
+	std::greater<uint64_t>>>>
+	roots;
+	std::unordered_map<nano::block_hash, std::shared_ptr<nano::election>> blocks;
+	std::deque<nano::election_status> 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<nano::block>, std::function<void(std::shared_ptr<nano::block>)> const & = [](std::shared_ptr<nano::block>) {});
+	void announce_loop ();
+	void announce_votes (std::unique_lock<std::mutex> &);
+	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<void()> function;
+};
+class alarm
+{
+public:
+	alarm (boost::asio::io_context &);
+	~alarm ();
+	void add (std::chrono::steady_clock::time_point const &, std::function<void()> const &);
+	void run ();
+	boost::asio::io_context & io_ctx;
+	std::mutex mutex;
+	std::condition_variable condition;
+	std::priority_queue<operation, std::vector<operation>, std::greater<operation>> operations;
+	boost::thread thread;
+};
+class gap_information
+{
+public:
+	std::chrono::steady_clock::time_point arrival;
+	nano::block_hash hash;
+	std::unordered_set<nano::account> voters;
+};
+class gap_cache
+{
+public:
+	gap_cache (nano::node &);
+	void add (nano::transaction const &, std::shared_ptr<nano::block>);
+	void vote (std::shared_ptr<nano::vote>);
+	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::member<gap_information, std::chrono::steady_clock::time_point, &gap_information::arrival>>,
+	boost::multi_index::hashed_unique<boost::multi_index::member<gap_information, nano::block_hash, &gap_information::hash>>>>
+	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<void(boost::system::error_code const &, size_t)> 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::member<nano::block_arrival_info, std::chrono::steady_clock::time_point, &nano::block_arrival_info::arrival>>,
+	boost::multi_index::hashed_unique<boost::multi_index::member<nano::block_arrival_info, nano::block_hash, &nano::block_arrival_info::hash>>>>
+	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<nano::vote> const &);
+	void recalculate_stake ();
+	nano::uint128_t online_stake ();
+	nano::uint128_t online_stake_total;
+	std::vector<nano::account> list ();
+	boost::multi_index_container<
+	nano::rep_last_heard_info,
+	boost::multi_index::indexed_by<
+	boost::multi_index::ordered_non_unique<boost::multi_index::member<nano::rep_last_heard_info, std::chrono::steady_clock::time_point, &nano::rep_last_heard_info::last_heard>>,
+	boost::multi_index::hashed_unique<boost::multi_index::member<nano::rep_last_heard_info, nano::account, &nano::rep_last_heard_info::representative>>>>
+	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<nano::udp_data *> free;
+	boost::circular_buffer<nano::udp_data *> full;
+	std::vector<uint8_t> slab;
+	std::vector<nano::udp_data> 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<nano::vote>);
+	void republish_block (std::shared_ptr<nano::block>);
+	static unsigned const broadcast_interval_ms = 10;
+	void republish_block_batch (std::deque<std::shared_ptr<nano::block>>, unsigned = broadcast_interval_ms);
+	void republish (nano::block_hash const &, std::shared_ptr<std::vector<uint8_t>>, nano::endpoint);
+	void confirm_send (nano::confirm_ack const &, std::shared_ptr<std::vector<uint8_t>>, nano::endpoint const &);
+	void merge_peers (std::array<nano::endpoint, 8> const &);
+	void send_keepalive (nano::endpoint const &);
+	void send_node_id_handshake (nano::endpoint const &, boost::optional<nano::uint256_union> const & query, boost::optional<nano::uint256_union> const & respond_to);
+	void broadcast_confirm_req (std::shared_ptr<nano::block>);
+	void broadcast_confirm_req_base (std::shared_ptr<nano::block>, std::shared_ptr<std::vector<nano::peer_information>>, unsigned, bool = false);
+	void broadcast_confirm_req_batch (std::deque<std::pair<std::shared_ptr<nano::block>, std::shared_ptr<std::vector<nano::peer_information>>>>, unsigned = broadcast_interval_ms);
+	void send_confirm_req (nano::endpoint const &, std::shared_ptr<nano::block>);
+	void send_buffer (uint8_t const *, size_t, nano::endpoint const &, std::function<void(boost::system::error_code const &, size_t)>);
+	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<boost::thread> 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<std::shared_ptr<nano::block>, nano::account const &, nano::uint128_t const &, bool> blocks;
+	nano::observer_set<bool> wallet;
+	nano::observer_set<nano::transaction const &, std::shared_ptr<nano::vote>, nano::endpoint const &> vote;
+	nano::observer_set<nano::account const &, bool> account_balance;
+	nano::observer_set<nano::endpoint const &> endpoint;
+	nano::observer_set<> disconnect;
+};
+class vote_processor
+{
+public:
+	vote_processor (nano::node &);
+	void vote (std::shared_ptr<nano::vote>, nano::endpoint);
+	// node.active.mutex lock required
+	nano::vote_code vote_blocking (nano::transaction const &, std::shared_ptr<nano::vote>, nano::endpoint, bool = false);
+	void verify_votes (std::deque<std::pair<std::shared_ptr<nano::vote>, nano::endpoint>> &);
+	void flush ();
+	void calculate_weights ();
+	nano::node & node;
+	void stop ();
+
+private:
+	void process_loop ();
+	std::deque<std::pair<std::shared_ptr<nano::vote>, nano::endpoint>> votes;
+	// Representatives levels for random early detection
+	std::unordered_set<nano::account> representatives_1;
+	std::unordered_set<nano::account> representatives_2;
+	std::unordered_set<nano::account> 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<nano::block_hash> 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<void> * 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<nano::signature_check_set> 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<nano::block>, std::chrono::steady_clock::time_point);
+	void force (std::shared_ptr<nano::block>);
+	bool should_log (bool);
+	bool have_blocks ();
+	void process_blocks ();
+	nano::process_return process_receive_one (nano::transaction const &, std::shared_ptr<nano::block>, 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<std::mutex> &, size_t = std::numeric_limits<size_t>::max ());
+	void process_receive_many (std::unique_lock<std::mutex> &);
+	bool stopped;
+	bool active;
+	std::chrono::steady_clock::time_point next_log;
+	std::deque<std::pair<std::shared_ptr<nano::block>, std::chrono::steady_clock::time_point>> state_blocks;
+	std::deque<std::pair<std::shared_ptr<nano::block>, std::chrono::steady_clock::time_point>> blocks;
+	std::unordered_set<nano::block_hash> blocks_hashes;
+	std::deque<std::shared_ptr<nano::block>> forced;
+	std::condition_variable condition;
+	nano::node & node;
+	nano::vote_generator generator;
+	std::mutex mutex;
+};
+class node : public std::enable_shared_from_this<nano::node>
+{
+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 <typename T>
+	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<nano::node> shared ();
+	int store_version ();
+	void process_confirmed (std::shared_ptr<nano::block>);
+	void process_message (nano::message &, nano::endpoint const &);
+	void process_active (std::shared_ptr<nano::block>);
+	nano::process_return process (nano::block const &);
+	void keepalive_preconfigured (std::vector<std::string> const &);
+	nano::block_hash latest (nano::account const &);
+	nano::uint128_t balance (nano::account const &);
+	std::shared_ptr<nano::block> block (nano::block_hash const &);
+	std::pair<nano::uint128_t, nano::uint128_t> 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<void(uint64_t)>, uint64_t = nano::work_pool::publish_threshold);
+	void add_initial_peers ();
+	void block_confirm (std::shared_ptr<nano::block>);
+	void process_fork (nano::transaction const &, std::shared_ptr<nano::block>);
+	bool validate_block_by_previous (nano::transaction const &, std::shared_ptr<nano::block>);
+	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<nano::block_store> 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<boost::thread> 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<boost::asio::io_context> io_context;
+	nano::alarm alarm;
+	nano::logging logging;
+	nano::node_init init;
+	nano::work_pool work;
+	uint16_t peering_port;
+	std::shared_ptr<nano::node> node;
+};
+}

nano/node/nodeconfig.cpp

@@ -1,19 +1,19 @@
-#include <rai/node/nodeconfig.hpp>
+#include <nano/node/nodeconfig.hpp>
 // 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 <rai/node/node.hpp>
+// once nano::network is factored out of node.{c|h}pp
+#include <nano/node/node.hpp>
 
-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<unsigned> (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<std::string> (""));
 				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<std::string> ());
+			tree_a.put ("receive_minimum", nano::xrb_ratio.convert_to<std::string> ());
 			result = true;
 		case 4:
 			tree_a.erase ("receive_minimum");
-			tree_a.put ("receive_minimum", rai::xrb_ratio.convert_to<std::string> ());
+			tree_a.put ("receive_minimum", nano::xrb_ratio.convert_to<std::string> ());
 			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<std::string> (""));
 			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),

nano/node/nodeconfig.hpp

@@ -2,12 +2,12 @@
 
 #include <boost/property_tree/ptree.hpp>
 #include <chrono>
-#include <rai/lib/numbers.hpp>
-#include <rai/node/logging.hpp>
-#include <rai/node/stats.hpp>
+#include <nano/lib/numbers.hpp>
+#include <nano/node/logging.hpp>
+#include <nano/node/stats.hpp>
 #include <vector>
 
-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<std::pair<std::string, uint16_t>> work_peers;
 	std::vector<std::string> preconfigured_peers;
-	std::vector<rai::account> preconfigured_representatives;
+	std::vector<nano::account> 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;

nano/node/openclwork.cpp

@@ -1,8 +1,8 @@
-#include <rai/node/openclwork.hpp>
+#include <nano/node/openclwork.hpp>
 
-#include <rai/lib/utility.hpp>
-#include <rai/node/node.hpp>
-#include <rai/node/wallet.hpp>
+#include <nano/lib/utility.hpp>
+#include <nano/node/node.hpp>
+#include <nano/node/wallet.hpp>
 
 #include <array>
 #include <iostream>
@@ -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<uint8_t *> (rand.s.data ()), rand.s.size () * sizeof (decltype (rand.s)::value_type));
+			nano::random_pool.GenerateBlock (reinterpret_cast<uint8_t *> (rand.s.data ()), rand.s.size () * sizeof (decltype (rand.s)::value_type));
 			std::array<cl_device_id, 1> 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<uint64_t> rai::opencl_work::generate_work (rai::uint256_union const & root_a)
+boost::optional<uint64_t> nano::opencl_work::generate_work (nano::uint256_union const & root_a)
 {
 	std::lock_guard<std::mutex> 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<uint64_t> rai::opencl_work::generate_work (rai::uint256_union co
 	return value;
 }
 
-std::unique_ptr<rai::opencl_work> rai::opencl_work::create (bool create_a, rai::opencl_config const & config_a, rai::logging & logging_a)
+std::unique_ptr<nano::opencl_work> nano::opencl_work::create (bool create_a, nano::opencl_config const & config_a, nano::logging & logging_a)
 {
-	std::unique_ptr<rai::opencl_work> result;
+	std::unique_ptr<nano::opencl_work> 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 ();

nano/node/openclwork.hpp

@@ -1,6 +1,6 @@
 #pragma once
 
-#include <rai/node/xorshift.hpp>
+#include <nano/node/xorshift.hpp>
 
 #include <boost/optional.hpp>
 #include <boost/property_tree/ptree.hpp>
@@ -16,7 +16,7 @@
 #include <CL/cl.h>
 #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<rai::opencl_platform> platforms;
+	std::vector<nano::opencl_platform> 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<uint64_t> generate_work (rai::uint256_union const &);
-	static std::unique_ptr<opencl_work> create (bool, rai::opencl_config const &, rai::logging &);
-	rai::opencl_config const & config;
+	boost::optional<uint64_t> generate_work (nano::uint256_union const &);
+	static std::unique_ptr<opencl_work> 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;
 };
 }

nano/node/peers.cpp

@@ -1,16 +1,16 @@
-#include <rai/node/peers.hpp>
+#include <nano/node/peers.hpp>
 
-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<std::mutex> lock (mutex);
 
-		if (peers.get<rai::peer_by_ip_addr> ().count (endpoint_l.address ()) < max_peers_per_ip)
+		if (peers.get<nano::peer_by_ip_addr> ().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<std::mutex> 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::endpoint> rai::peer_container::list_fanout ()
+std::deque<nano::endpoint> nano::peer_container::list_fanout ()
 {
 	auto peers (random_set (size_sqrt ()));
-	std::deque<rai::endpoint> result;
+	std::deque<nano::endpoint> result;
 	for (auto i (peers.begin ()), n (peers.end ()); i != n; ++i)
 	{
 		result.push_back (*i);
@@ -84,9 +84,9 @@ std::deque<rai::endpoint> rai::peer_container::list_fanout ()
 	return result;
 }
 
-std::deque<rai::endpoint> rai::peer_container::list ()
+std::deque<nano::endpoint> nano::peer_container::list ()
 {
-	std::deque<rai::endpoint> result;
+	std::deque<nano::endpoint> result;
 	std::lock_guard<std::mutex> lock (mutex);
 	for (auto i (peers.begin ()), j (peers.end ()); i != j; ++i)
 	{
@@ -96,18 +96,18 @@ std::deque<rai::endpoint> rai::peer_container::list ()
 	return result;
 }
 
-std::map<rai::endpoint, unsigned> rai::peer_container::list_version ()
+std::map<nano::endpoint, unsigned> nano::peer_container::list_version ()
 {
-	std::map<rai::endpoint, unsigned> result;
+	std::map<nano::endpoint, unsigned> result;
 	std::lock_guard<std::mutex> lock (mutex);
 	for (auto i (peers.begin ()), j (peers.end ()); i != j; ++i)
 	{
-		result.insert (std::pair<rai::endpoint, unsigned> (i->endpoint, i->network_version));
+		result.insert (std::pair<nano::endpoint, unsigned> (i->endpoint, i->network_version));
 	}
 	return result;
 }
 
-std::vector<rai::peer_information> rai::peer_container::list_vector (size_t count_a)
+std::vector<nano::peer_information> nano::peer_container::list_vector (size_t count_a)
 {
 	std::vector<peer_information> result;
 	std::lock_guard<std::mutex> lock (mutex);
@@ -118,14 +118,14 @@ std::vector<rai::peer_information> 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<std::mutex> 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::uint256_union> rai::peer_container::assign_syn_cookie (rai::endpoint const & endpoint)
+boost::optional<nano::uint256_union> nano::peer_container::assign_syn_cookie (nano::endpoint const & endpoint)
 {
 	auto ip_addr (endpoint.address ());
 	assert (ip_addr.is_v6 ());
 	std::unique_lock<std::mutex> lock (syn_cookie_mutex);
 	unsigned & ip_cookies = syn_cookies_per_ip[ip_addr];
-	boost::optional<rai::uint256_union> result;
+	boost::optional<nano::uint256_union> 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::uint256_union> 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<std::mutex> 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::endpoint> rai::peer_container::random_set (size_t count_a)
+std::unordered_set<nano::endpoint> nano::peer_container::random_set (size_t count_a)
 {
-	std::unordered_set<rai::endpoint> result;
+	std::unordered_set<nano::endpoint> result;
 	result.reserve (count_a);
 	std::lock_guard<std::mutex> lock (mutex);
 	// Stop trying to fill result with random samples after this many attempts
@@ -218,11 +218,11 @@ std::unordered_set<rai::endpoint> rai::peer_container::random_set (size_t count_
 	return result;
 }
 
-void rai::peer_container::random_fill (std::array<rai::endpoint, 8> & target_a)
+void nano::peer_container::random_fill (std::array<nano::endpoint, 8> & 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<rai::endpoint, 8> & target_a)
 }
 
 // Request a list of the top known representatives
-std::vector<rai::peer_information> rai::peer_container::representatives (size_t count_a)
+std::vector<nano::peer_information> nano::peer_container::representatives (size_t count_a)
 {
 	std::vector<peer_information> result;
 	result.reserve (std::min (count_a, size_t (16)));
@@ -250,7 +250,7 @@ std::vector<rai::peer_information> 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<std::mutex> 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_information> rai::peer_container::purge_list (std::chrono::steady_clock::time_point const & cutoff)
+std::vector<nano::peer_information> nano::peer_container::purge_list (std::chrono::steady_clock::time_point const & cutoff)
 {
-	std::vector<rai::peer_information> result;
+	std::vector<nano::peer_information> result;
 	{
 		std::lock_guard<std::mutex> lock (mutex);
 		auto pivot (peers.get<1> ().lower_bound (cutoff));
@@ -288,7 +288,7 @@ std::vector<rai::peer_information> 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_information> rai::peer_container::purge_list (std::chrono:
 	return result;
 }
 
-std::vector<rai::endpoint> rai::peer_container::rep_crawl ()
+std::vector<nano::endpoint> nano::peer_container::rep_crawl ()
 {
-	std::vector<rai::endpoint> result;
+	std::vector<nano::endpoint> 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::endpoint> rai::peer_container::rep_crawl ()
 	return result;
 }
 
-size_t rai::peer_container::size ()
+size_t nano::peer_container::size ()
 {
 	std::lock_guard<std::mutex> 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_information> rai::peer_container::list_probable_rep_weights ()
+std::vector<nano::peer_information> nano::peer_container::list_probable_rep_weights ()
 {
-	std::vector<rai::peer_information> result;
-	std::unordered_set<rai::account> probable_reps;
+	std::vector<nano::peer_information> result;
+	std::unordered_set<nano::account> probable_reps;
 	std::lock_guard<std::mutex> 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_information> 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<std::mutex> 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<std::mutex> 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<std::mutex> 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<rai::peer_by_ip_addr> ().count (endpoint_a.address ()));
+					auto ip_peers (peers.get<nano::peer_by_ip_addr> ().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));
 				}
 			}
 		}