diff --git a/.clang-format.base b/.clang-format similarity index 91% rename from .clang-format.base rename to .clang-format index a1e26efb78..75531323c6 100644 --- a/.clang-format.base +++ b/.clang-format @@ -1,10 +1,10 @@ --- BasedOnStyle: Webkit -Language: Cpp +Language: Cpp SpaceBeforeParens: Always SpaceAfterTemplateKeyword: true -Standard: Cpp11 -TabWidth: 4 +Standard: Cpp11 +TabWidth: 4 IndentWidth: 4 PointerAlignment: Middle UseTab: ForContinuationAndIndentation @@ -15,9 +15,9 @@ AllowShortCaseLabelsOnASingleLine: false AllowShortFunctionsOnASingleLine: false AllowShortLambdasOnASingleLine: All AllowShortLoopsOnASingleLine: false -BreakConstructorInitializersBeforeComma: true BreakConstructorInitializers: AfterColon ConstructorInitializerAllOnOneLineOrOnePerLine: false +ConstructorInitializerIndentWidth: 4 ContinuationIndentWidth: 0 KeepEmptyLinesAtTheStartOfBlocks: false IndentCaseLabels: true @@ -34,7 +34,6 @@ BraceWrapping: AfterClass: true BeforeCatch: true BeforeElse: true - BeforeLambdaBody: true SplitEmptyRecord: true SplitEmptyNamespace: true SortIncludes: true diff --git a/.github/ISSUE_TEMPLATE.md b/.github/ISSUE_TEMPLATE.md index b85184a9ef..cfb468b5c3 100644 --- a/.github/ISSUE_TEMPLATE.md +++ b/.github/ISSUE_TEMPLATE.md @@ -1,79 +1,19 @@ - -**Description of bug:** - - - -**Steps to reproduce the issue:** -1. -2. -3. - -**Describe the results you received:** - - -**Describe the results you expected:** - - -**Additional information you deem important (e.g. issue happens only occasionally):** - -**Environment**: - - - -**logs** - - diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml index 101dd62ed8..09fd58f2ee 100644 --- a/.github/ISSUE_TEMPLATE/config.yml +++ b/.github/ISSUE_TEMPLATE/config.yml @@ -1,4 +1,4 @@ -blank_issues_enabled: false +blank_issues_enabled: true contact_links: - name: Report a security vulnerability url: https://docs.nano.org/node-implementation/contributing/#security-vulnerability-disclosure diff --git a/.github/workflows/analyzers.yml b/.github/workflows/analyzers.yml index ac4d7d2f1e..cea239a81e 100644 --- a/.github/workflows/analyzers.yml +++ b/.github/workflows/analyzers.yml @@ -4,23 +4,19 @@ on: [push, pull_request] jobs: clang_format: - runs-on: ubuntu-18.04 + runs-on: ubuntu-20.04 if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository steps: - uses: actions/checkout@50fbc622fc4ef5163becd7fab6573eac35f8462e - - name: Installing clang-format 10 + - name: Installing clang-format 12 env: DEBIAN_FRONTEND: noninteractive - run: sudo apt-get install clang-format-10 - - name: Setting clang-format 10 as the default - env: - DEBIAN_FRONTEND: noninteractive - run: sudo update-alternatives --install /usr/bin/clang-format clang-format /usr/bin/clang-format-10 1000 - - name: Clang Format - run: ci/check-commit-format.sh + run: sudo apt-get install clang-format-12 + - name: Check clang-format + run: ci/clang-format-check.sh cmake_format: - runs-on: ubuntu-18.04 + runs-on: ubuntu-20.04 if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository steps: - uses: actions/checkout@50fbc622fc4ef5163becd7fab6573eac35f8462e @@ -33,4 +29,4 @@ jobs: packages: | cmake-format - name: Check cmake-format - run: bash ci/check-cmake-format.sh + run: ci/cmake-format-check.sh diff --git a/.github/workflows/beta_artifacts.yml b/.github/workflows/beta_artifacts.yml index c930326176..81bda27494 100644 --- a/.github/workflows/beta_artifacts.yml +++ b/.github/workflows/beta_artifacts.yml @@ -16,7 +16,7 @@ env: jobs: osx_job: - runs-on: macos-latest + runs-on: macOS-10.15 timeout-minutes: 90 env: BOOST_ROOT: /tmp/boost @@ -41,7 +41,7 @@ jobs: AWS_DEFAULT_REGION: us-east-2 linux_job: - runs-on: ubuntu-18.04 + runs-on: ubuntu-20.04 timeout-minutes: 90 steps: - name: tag @@ -66,7 +66,7 @@ jobs: AWS_DEFAULT_REGION: us-east-2 linux_docker_job: - runs-on: ubuntu-18.04 + runs-on: ubuntu-20.04 timeout-minutes: 90 steps: - name: tag @@ -118,4 +118,4 @@ jobs: env: AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }} AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }} - AWS_DEFAULT_REGION: us-east-2 \ No newline at end of file + AWS_DEFAULT_REGION: us-east-2 diff --git a/.github/workflows/coverage.yml b/.github/workflows/coverage.yml new file mode 100644 index 0000000000..b0a9f5f3ec --- /dev/null +++ b/.github/workflows/coverage.yml @@ -0,0 +1,56 @@ +name: Coverage Reports + +on: + workflow_dispatch: + inputs: + label: + description: "label to append to run" + default: "Scheduled" + required: true + schedule: + - cron: "0 1 * * 0" +jobs: + coverage_test: + name: Coverage Test [TEST_USE_ROCKSDB=${{ matrix.TEST_USE_ROCKSDB }}] + if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository + env: + LCOV: 1 + COMPILER: gcc + BOOST_ROOT: /tmp/boost + runs-on: ubuntu-20.04 + strategy: + matrix: + TEST_USE_ROCKSDB: [0, 1] + fail-fast: false + continue-on-error: true + timeout-minutes: 60 + steps: + - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f + with: + submodules: "recursive" + - name: Fetch Deps + run: | + sudo apt-get update -qq && sudo apt-get install -yqq build-essential g++ wget python zlib1g-dev qt5-default \ + valgrind xorg xvfb xauth xfonts-100dpi xfonts-75dpi xfonts-scalable xfonts-cyrillic ocl-icd-opencl-dev \ + git lcov python3-pip + util/build_prep/fetch_boost.sh + wget -O cmake_install.sh https://github.com/Kitware/CMake/releases/download/v3.15.4/cmake-3.15.4-Linux-x86_64.sh + chmod +x cmake_install.sh + sudo ./cmake_install.sh --prefix=/usr --exclude-subdir --skip-license + - name: Build and Test + env: + TEST_USE_ROCKSDB: ${{ matrix.TEST_USE_ROCKSDB }} + run: ./ci/build-travis.sh /usr/lib/x86_64-linux=gnu/cmake/Qt5 + - uses: coverallsapp/github-action@8cbef1dea373ebce56de0a14c68d6267baa10b44 + with: + github-token: ${{ secrets.github_token }} + flag-name: rocksdb-${{ matrix.TEST_USE_ROCKSDB }},${{ github.event.inputs.label }} + parallel: true + finish: + needs: coverage_test + runs-on: ubuntu-20.04 + steps: + - uses: coverallsapp/github-action@8cbef1dea373ebce56de0a14c68d6267baa10b44 + with: + github-token: ${{ secrets.github_token }} + parallel-finished: true \ No newline at end of file diff --git a/.github/workflows/develop.yml b/.github/workflows/develop.yml index 4a42219576..a556f38fb4 100644 --- a/.github/workflows/develop.yml +++ b/.github/workflows/develop.yml @@ -3,10 +3,10 @@ name: Develop on: push: branches: - - develop + - develop jobs: linux_job: - runs-on: ubuntu-18.04 + runs-on: ubuntu-20.04 steps: - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f with: @@ -24,4 +24,4 @@ jobs: - name: Deploy Docker (nanocurrency/nano-env) run: ci/actions/linux/deploy-docker.sh env: - DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }} \ No newline at end of file + DOCKER_PASSWORD: ${{ secrets.DOCKER_PASSWORD }} diff --git a/.github/workflows/live_artifacts.yml b/.github/workflows/live_artifacts.yml index 3cca372e8e..bc852f2c92 100644 --- a/.github/workflows/live_artifacts.yml +++ b/.github/workflows/live_artifacts.yml @@ -15,7 +15,7 @@ env: jobs: osx_job: - runs-on: macos-latest + runs-on: macOS-10.15 timeout-minutes: 90 env: BOOST_ROOT: /tmp/boost @@ -40,7 +40,7 @@ jobs: AWS_DEFAULT_REGION: us-east-2 linux_job: - runs-on: ubuntu-18.04 + runs-on: ubuntu-20.04 timeout-minutes: 90 steps: - name: tag @@ -65,7 +65,7 @@ jobs: AWS_DEFAULT_REGION: us-east-2 linux_docker_job: - runs-on: ubuntu-18.04 + runs-on: ubuntu-20.04 timeout-minutes: 90 steps: - name: tag @@ -117,4 +117,4 @@ jobs: env: AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }} AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }} - AWS_DEFAULT_REGION: us-east-2 \ No newline at end of file + AWS_DEFAULT_REGION: us-east-2 diff --git a/.github/workflows/release_tests.yml b/.github/workflows/release_tests.yml deleted file mode 100644 index e6cb9d3270..0000000000 --- a/.github/workflows/release_tests.yml +++ /dev/null @@ -1,62 +0,0 @@ -name: Release Tests - -on: - push: - tags: '*' - -env: - RELEASE: 1 - artifact: 0 - -jobs: - osx_test: - runs-on: macos-latest - env: - BOOST_ROOT: /tmp/boost - steps: - - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f - with: - submodules: "recursive" - - - name: Fetch Deps - run: TEST=1 ci/actions/osx/install_deps.sh - - name: Run Tests - run: ci/build-travis.sh "/tmp/qt/lib/cmake/Qt5"; - - gcc_test: - runs-on: ubuntu-18.04 - timeout-minutes: 60 - steps: - - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f - with: - submodules: "recursive" - - - name: Fetch Deps - run: ci/actions/linux/install_deps.sh - - name: Run Tests - run: docker run -v ${PWD}:/workspace nanocurrency/nano-env:gcc /bin/bash -c "cd /workspace && RELEASE=1 ./ci/build-travis.sh /usr/lib/x86_64-linux-gnu/cmake/Qt5 ${PWD}" - - clang_test: - runs-on: ubuntu-18.04 - timeout-minutes: 60 - steps: - - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f - with: - submodules: "recursive" - - - name: Fetch Deps - run: ci/actions/linux/install_deps.sh - - name: Run Tests - run: docker run -v ${PWD}:/workspace nanocurrency/nano-env:clang-6 /bin/bash -c "cd /workspace && RELEASE=1 ./ci/build-travis.sh /usr/lib/x86_64-linux-gnu/cmake/Qt5 ${PWD}" - - windows_test: - runs-on: windows-latest - timeout-minutes: 60 - steps: - - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f - with: - submodules: "recursive" - - name: Fetch Deps - run: ci/actions/windows/install_deps.ps1 - - name: Run Tests - run: ci/actions/windows/build.ps1 diff --git a/.github/workflows/rocksdb_release_tests.yml b/.github/workflows/rocksdb_release_tests.yml deleted file mode 100644 index de2fbe34e7..0000000000 --- a/.github/workflows/rocksdb_release_tests.yml +++ /dev/null @@ -1,48 +0,0 @@ -name: RocksDB Release Tests - -on: - push: - tags: '*' - -env: - RELEASE: 1 - artifact: 0 - TEST_USE_ROCKSDB: 1 - -jobs: - osx_test: - runs-on: macos-latest - env: - BOOST_ROOT: /tmp/boost - steps: - - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f - with: - submodules: "recursive" - - name: Fetch Deps - run: TEST=1 ci/actions/osx/install_deps.sh - - name: Run Tests - run: ci/build-travis.sh "/tmp/qt/lib/cmake/Qt5"; - - gcc_test: - runs-on: ubuntu-18.04 - timeout-minutes: 60 - steps: - - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f - with: - submodules: "recursive" - - name: Fetch Deps - run: ci/actions/linux/install_deps.sh - - name: Run Tests - run: docker run -e TEST_USE_ROCKSDB -v ${PWD}:/workspace nanocurrency/nano-env:gcc /bin/bash -c "cd /workspace && RELEASE=1 ./ci/build-travis.sh /usr/lib/x86_64-linux-gnu/cmake/Qt5 ${PWD}" - - clang_test: - runs-on: ubuntu-18.04 - timeout-minutes: 60 - steps: - - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f - with: - submodules: "recursive" - - name: Fetch Deps - run: ci/actions/linux/install_deps.sh - - name: Run Tests - run: docker run -e TEST_USE_ROCKSDB -v ${PWD}:/workspace nanocurrency/nano-env:clang-6 /bin/bash -c "cd /workspace && RELEASE=1 ./ci/build-travis.sh /usr/lib/x86_64-linux-gnu/cmake/Qt5 ${PWD}" diff --git a/.github/workflows/rocksdb_tests.yml b/.github/workflows/rocksdb_tests.yml deleted file mode 100644 index 94b52d0425..0000000000 --- a/.github/workflows/rocksdb_tests.yml +++ /dev/null @@ -1,68 +0,0 @@ -name: RocksDB Tests - -on: [push, pull_request] - -env: - RELEASE: 0 - artifact: 0 - TEST_USE_ROCKSDB: 1 - -jobs: - osx_test: - runs-on: macos-latest - env: - BOOST_ROOT: /tmp/boost - DEADLINE_SCALE_FACTOR: 2 - if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository - steps: - - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f - with: - submodules: "recursive" - - name: Fetch Deps - run: TEST=1 ci/actions/osx/install_deps.sh - - name: Run Tests - run: ci/build-travis.sh "/tmp/qt/lib/cmake/Qt5"; - - gcc_test: - runs-on: ubuntu-18.04 - timeout-minutes: 60 - if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository - steps: - - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f - with: - submodules: "recursive" - - name: Fetch Deps - run: ci/actions/linux/install_deps.sh - - name: Run Tests - run: docker run -e TEST_USE_ROCKSDB -v ${PWD}:/workspace nanocurrency/nano-env:gcc /bin/bash -c "cd /workspace && ./ci/build-travis.sh /usr/lib/x86_64-linux-gnu/cmake/Qt5 ${PWD}" - - clang_test: - runs-on: ubuntu-18.04 - timeout-minutes: 60 - if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository - steps: - - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f - with: - submodules: "recursive" - - name: Fetch Deps - run: ci/actions/linux/install_deps.sh - - name: Run Tests - run: docker run -e TEST_USE_ROCKSDB -v ${PWD}:/workspace nanocurrency/nano-env:clang-6 /bin/bash -c "cd /workspace && ./ci/build-travis.sh /usr/lib/x86_64-linux-gnu/cmake/Qt5 ${PWD}" - - windows_test: - runs-on: windows-latest - timeout-minutes: 60 - env: - RELEASE: 1 - DEADLINE_SCALE_FACTOR: 2 - if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository - steps: - - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f - with: - submodules: "recursive" - - name: Windows Defender - run: ci/actions/windows/disable_windows_defender.ps1 - - name: Fetch Deps - run: ci/actions/windows/install_deps.ps1 - - name: Run Tests - run: ci/actions/windows/build.ps1 diff --git a/.github/workflows/test_network_artifacts.yml b/.github/workflows/test_network_artifacts.yml index 479b8efba0..991d90c4be 100644 --- a/.github/workflows/test_network_artifacts.yml +++ b/.github/workflows/test_network_artifacts.yml @@ -16,7 +16,7 @@ env: jobs: osx_job: - runs-on: macos-latest + runs-on: macOS-10.15 timeout-minutes: 90 env: BOOST_ROOT: /tmp/boost @@ -41,7 +41,7 @@ jobs: AWS_DEFAULT_REGION: us-east-2 linux_job: - runs-on: ubuntu-18.04 + runs-on: ubuntu-20.04 timeout-minutes: 90 steps: - name: tag @@ -66,7 +66,7 @@ jobs: AWS_DEFAULT_REGION: us-east-2 linux_docker_job: - runs-on: ubuntu-18.04 + runs-on: ubuntu-20.04 timeout-minutes: 90 steps: - name: tag @@ -118,4 +118,4 @@ jobs: env: AWS_ACCESS_KEY_ID: ${{ secrets.AWS_ACCESS_KEY_ID }} AWS_SECRET_ACCESS_KEY: ${{ secrets.AWS_SECRET_ACCESS_KEY }} - AWS_DEFAULT_REGION: us-east-2 \ No newline at end of file + AWS_DEFAULT_REGION: us-east-2 diff --git a/.github/workflows/tests.yml b/.github/workflows/tests.yml index c429d6779a..b0902cc164 100644 --- a/.github/workflows/tests.yml +++ b/.github/workflows/tests.yml @@ -5,12 +5,21 @@ on: [push, pull_request] env: RELEASE: 0 artifact: 0 - + jobs: osx_test: - runs-on: macos-latest + name: OSX unit tests [TEST_USE_ROCKSDB=${{ matrix.TEST_USE_ROCKSDB }}] + strategy: + fail-fast: false + matrix: + TEST_USE_ROCKSDB: [0, 1] + RELEASE: + - ${{ startsWith(github.ref, 'refs/tags/') }} env: BOOST_ROOT: /tmp/boost + TEST_USE_ROCKSDB: ${{ matrix.TEST_USE_ROCKSDB }} + RELEASE: ${{ matrix.RELEASE }} + runs-on: macOS-10.15 if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository steps: - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f @@ -18,25 +27,32 @@ jobs: submodules: "recursive" - name: Fetch Deps run: TEST=1 ci/actions/osx/install_deps.sh - - name: Run Tests + - name: Build Tests run: ci/build-travis.sh "/tmp/qt/lib/cmake/Qt5"; + - name: Run Tests lmdb + if: ${{ matrix.TEST_USE_ROCKSDB == 0 }} + run: cd build && sudo TEST_USE_ROCKSDB=$TEST_USE_ROCKSDB ../ci/test.sh . + - name: Run Tests rocksdb + env: + DEADLINE_SCALE_FACTOR: 2 + if: ${{ matrix.TEST_USE_ROCKSDB == 1 }} + run: cd build && sudo TEST_USE_ROCKSDB=$TEST_USE_ROCKSDB ../ci/test.sh . - gcc_test: - runs-on: ubuntu-18.04 - timeout-minutes: 60 - if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository - steps: - - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f - with: - submodules: "recursive" - - name: Fetch Deps - run: ci/actions/linux/install_deps.sh - - name: Run Tests - run: docker run -v ${PWD}:/workspace nanocurrency/nano-env:gcc /bin/bash -c "cd /workspace && ./ci/build-travis.sh /usr/lib/x86_64-linux-gnu/cmake/Qt5 ${PWD}" - - clang_test: - runs-on: ubuntu-18.04 - timeout-minutes: 60 + linux_test: + name: Linux Unit Tests [TEST_USE_ROCKSDB=${{ matrix.TEST_USE_ROCKSDB }} - COMPILER=${{ matrix.COMPILER }}] + timeout-minutes: 90 + strategy: + fail-fast: false + matrix: + TEST_USE_ROCKSDB: [0, 1] + COMPILER: [gcc, clang-6] + RELEASE: + - ${{ startsWith(github.ref, 'refs/tags/') }} + runs-on: ubuntu-20.04 + env: + COMPILER: ${{ matrix.COMPILER }} + TEST_USE_ROCKSDB: ${{ matrix.TEST_USE_ROCKSDB }} + RELEASE: ${{ matrix.RELEASE }} if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository steps: - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f @@ -44,12 +60,31 @@ jobs: submodules: "recursive" - name: Fetch Deps run: ci/actions/linux/install_deps.sh - - name: Run Tests - run: docker run -v ${PWD}:/workspace nanocurrency/nano-env:clang-6 /bin/bash -c "cd /workspace && ./ci/build-travis.sh /usr/lib/x86_64-linux-gnu/cmake/Qt5 ${PWD}" + - name: Build Tests + run: docker run -e TEST_USE_ROCKSDB -e RELEASE -v ${PWD}:/workspace nanocurrency/nano-env:${{ matrix.COMPILER }} /bin/bash -c "cd /workspace && ./ci/build-travis.sh /usr/lib/x86_64-linux-gnu/cmake/Qt5" + - name: Run Tests lmdb + if: ${{ matrix.TEST_USE_ROCKSDB == 0 }} + run: docker run -e RELEASE -v ${PWD}:/workspace nanocurrency/nano-env:${{ matrix.COMPILER }} /bin/bash -c "cd /workspace/build && ../ci/test.sh ." + - name: Run Tests rocksdb + if: ${{ matrix.TEST_USE_ROCKSDB == 1 }} + run: docker run -e TEST_USE_ROCKSDB -e DEADLINE_SCALE_FACTOR=2 -e RELEASE -v ${PWD}:/workspace nanocurrency/nano-env:${{ matrix.COMPILER }} /bin/bash -c "cd /workspace/build && ../ci/test.sh ." windows_test: + name: Windows Unit Tests [TEST_USE_ROCKSDB=${{ matrix.TEST_USE_ROCKSDB }}] + timeout-minutes: 90 + strategy: + fail-fast: false + matrix: + TEST_USE_ROCKSDB: [0, 1] + RELEASE: + - ${{ startsWith(github.ref, 'refs/tags/') }} + exclude: + - RELEASE: true + TEST_USE_ROCKSDB: 1 runs-on: windows-latest - timeout-minutes: 60 + env: + TEST_USE_ROCKSDB: ${{ matrix.TEST_USE_ROCKSDB }} + RELEASE: ${{ matrix.RELEASE }} if: github.event_name == 'push' || github.event.pull_request.head.repo.full_name != github.repository steps: - uses: actions/checkout@5a4ac9002d0be2fb38bd78e4b4dbde5606d7042f @@ -57,8 +92,13 @@ jobs: submodules: "recursive" - name: Windows Defender run: ci/actions/windows/disable_windows_defender.ps1 - - name: Fetch Deps run: ci/actions/windows/install_deps.ps1 - - name: Run Tests + - name: Run Tests lmdb + if: ${{ matrix.TEST_USE_ROCKSDB == 0 }} + run: ci/actions/windows/build.ps1 + - name: Run Tests rocksdb + if: ${{ matrix.TEST_USE_ROCKSDB == 1 }} + env: + DEADLINE_SCALE_FACTOR: 2 run: ci/actions/windows/build.ps1 diff --git a/.gitignore b/.gitignore index edd1b4e0eb..eef7f3c2df 100644 --- a/.gitignore +++ b/.gitignore @@ -61,7 +61,6 @@ Release # Autogenerated Qt artifacts packaging qrc_resources.cpp -qt_system resources.qrc.depends # Autogenerated Flatbuffers source files @@ -82,6 +81,3 @@ Testing # Autogenerated Build Prep artifacts util/build_prep/*/prep.sh - -# Autogenerated Tooling -.clang-format diff --git a/.gitmodules b/.gitmodules index bd4e9f6d98..42797ca5e1 100644 --- a/.gitmodules +++ b/.gitmodules @@ -14,7 +14,6 @@ [submodule "gtest"] path = gtest url = https://github.com/google/googletest.git - branch = v1.8.x [submodule "cpptoml"] path = cpptoml url = https://github.com/cryptocode/cpptoml.git @@ -28,3 +27,6 @@ path = rocksdb url = https://github.com/nanocurrency/rocksdb.git branch = 6.13.3 +[submodule "diskhash"] + path = diskhash + url = https://github.com/nanocurrency/diskhash.git diff --git a/CMakeLists.txt b/CMakeLists.txt index f61db1b783..f286a9c295 100644 --- a/CMakeLists.txt +++ b/CMakeLists.txt @@ -29,6 +29,15 @@ execute_process( OUTPUT_STRIP_TRAILING_WHITESPACE) option(CI_BUILD false) + +set(COVERAGE + OFF + CACHE BOOL "Code Coverage Targets") +if(COVERAGE) + list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules") + include(CoverageTest) +endif() + set(CI_TEST 0 CACHE STRING "") @@ -37,8 +46,8 @@ if(MSVC) add_definitions(/MP) endif() -set(CPACK_PACKAGE_VERSION_MAJOR "22") -set(CPACK_PACKAGE_VERSION_MINOR "1") +set(CPACK_PACKAGE_VERSION_MAJOR "23") +set(CPACK_PACKAGE_VERSION_MINOR "0") set(CPACK_PACKAGE_VERSION_PATCH "0") set(CPACK_PACKAGE_VERSION_PRE_RELEASE "0") set(CPACK_PACKAGE_VENDOR "Bananocoin") @@ -378,6 +387,12 @@ list(APPEND CMAKE_MODULE_PATH "${CMAKE_SOURCE_DIR}/cmake/Modules") find_package(Boost 1.70.0 REQUIRED COMPONENTS filesystem log log_setup thread program_options system) +# diskhash +if(NOT CMAKE_SYSTEM_NAME STREQUAL "Windows") + add_library(diskhash STATIC ${CMAKE_SOURCE_DIR}/diskhash/src/diskhash.c) + include_directories(diskhash/src) +endif() + # RocksDB include_directories(rocksdb/include) set(USE_RTTI @@ -464,6 +479,7 @@ set(CRYPTOPP_LIBRARY cryptopp) add_library( cryptopp crypto/cryptopp/algparam.cpp + crypto/cryptopp/allocate.cpp crypto/cryptopp/asn.cpp crypto/cryptopp/basecode.cpp crypto/cryptopp/cpu.cpp @@ -579,6 +595,8 @@ if(NANO_TEST OR RAIBLOCKS_TEST) add_subdirectory(nano/load_test) + # FIXME: This fixes googletest GOOGLETEST_VERSION requirement + set(GOOGLETEST_VERSION 1.11.0) add_subdirectory(gtest/googletest) # FIXME: This fixes gtest include directories without modifying gtest's # CMakeLists.txt. Ideally we should use GTest::GTest and GTest::Main as @@ -591,6 +609,17 @@ if(NANO_TEST OR RAIBLOCKS_TEST) add_subdirectory(nano/core_test) add_subdirectory(nano/rpc_test) add_subdirectory(nano/slow_test) + add_custom_target( + build_tests + COMMAND echo "BATCH BUILDING TESTS" + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + DEPENDS core_test load_test rpc_test nano_node nano_rpc) + + add_custom_target( + run_tests + COMMAND ${PROJECT_SOURCE_DIR}/ci/test.sh ${CMAKE_BINARY_DIR} + WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} + DEPENDS build_tests) endif() if(NANO_GUI OR RAIBLOCKS_GUI) install(FILES ${PROJECT_BINARY_DIR}/config-node.toml.sample DESTINATION .) @@ -656,13 +685,9 @@ if(NANO_GUI OR RAIBLOCKS_GUI) SUFFIX ".com") endif() - add_executable(qt_system 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") + qt nano_wallet PROPERTIES COMPILE_FLAGS + "-DQT_NO_KEYWORDS -DBOOST_ASIO_HAS_STD_ARRAY=1") if(NANO_TEST OR RAIBLOCKS_TEST) add_executable(qt_test nano/qt_test/entry.cpp nano/qt_test/qt.cpp) @@ -680,6 +705,7 @@ if(NANO_GUI OR RAIBLOCKS_GUI) set_target_properties( qt_test PROPERTIES COMPILE_FLAGS "-DQT_NO_KEYWORDS -DBOOST_ASIO_HAS_STD_ARRAY=1") + add_dependencies(build_tests qt_test) endif() if(APPLE) @@ -829,5 +855,9 @@ if(NANO_GUI OR RAIBLOCKS_GUI) endif() endif() +if(COVERAGE) + add_subdirectory(coverage) +endif() + set(CPACK_RESOURCE_FILE_LICENSE ${CMAKE_SOURCE_DIR}/LICENSE) include(CPack) diff --git a/Nano.icns b/Nano.icns index 0c48d6ac8a..e1aa7a79ac 100644 Binary files a/Nano.icns and b/Nano.icns differ diff --git a/SECURITY.md b/SECURITY.md index 5b96813aa1..1e8d4fd604 100644 --- a/SECURITY.md +++ b/SECURITY.md @@ -19,11 +19,10 @@ To report security issues in the Nano protocol, please send an email to security | GitHub Username | Email | GPG Pubkey | |-----------------------|--------|-----------------| -| [clemahieu](https://github.com/clemahieu) | clemahieu { at } gmail.com | [clemahieu.asc](https://github.com/BananoCoin/banano/blob/develop/etc/gpg/clemahieu.asc) | -| [argakiig](https://github.com/argakiig) | russel { at } nano.org | [argakiig.asc](https://github.com/BananoCoin/banano/blob/develop/etc/gpg/argakiig.asc) | -| [wezrule](https://github.com/wezrule) | wezrule { at } hotmail.com | [wezrule.asc](https://github.com/BananoCoin/banano/blob/develop/etc/gpg/wezrule.asc) | -| [sergiysw](https://github.com/sergiysw) | sergiysw { at } gmail.com | [sergiysw.asc](https://github.com/BananoCoin/banano/blob/develop/etc/gpg/sergiysw.asc) | -| [zhyatt](https://github.com/zhyatt) | zach { at } nano.org | [zhyatt.asc](https://github.com/BananoCoin/banano/blob/develop/etc/gpg/zhyatt.asc) | +| [clemahieu](https://github.com/clemahieu) | clemahieu { at } gmail.com | [clemahieu.asc](https://github.com/nanocurrency/nano-node/blob/develop/etc/gpg/clemahieu.asc) | +| [argakiig](https://github.com/argakiig) | russel { at } nano.org | [argakiig.asc](https://github.com/nanocurrency/nano-node/blob/develop/etc/gpg/argakiig.asc) | +| [sergiysw](https://github.com/sergiysw) | sergiysw { at } gmail.com | [sergiysw.asc](https://github.com/nanocurrency/nano-node/blob/develop/etc/gpg/sergiysw.asc) | +| [zhyatt](https://github.com/zhyatt) | zach { at } nano.org | [zhyatt.asc](https://github.com/nanocurrency/nano-node/blob/develop/etc/gpg/zhyatt.asc) | For details on how to send a GPG encrypted email, see the tutorial here: https://www.linode.com/docs/security/encryption/gpg-keys-to-send-encrypted-messages/. diff --git a/ci/actions/deploy.sh b/ci/actions/deploy.sh index e305daf003..4aee6f1d6e 100755 --- a/ci/actions/deploy.sh +++ b/ci/actions/deploy.sh @@ -5,9 +5,9 @@ set -o nounset set -o xtrace OS=$(uname) -if [[ "${BETA-0}" -eq 1 ]]; then +if [[ "${BETA:-0}" -eq 1 ]]; then BUILD="beta" -elif [[ "${TEST-0}" -eq 1 ]]; then +elif [[ "${TEST:-0}" -eq 1 ]]; then BUILD="test" else BUILD="live" diff --git a/ci/actions/linux/deploy-docker.sh b/ci/actions/linux/deploy-docker.sh index ae15e32eae..91457471e8 100755 --- a/ci/actions/linux/deploy-docker.sh +++ b/ci/actions/linux/deploy-docker.sh @@ -51,7 +51,7 @@ if [ -n "$DOCKER_PASSWORD" ]; then echo "Deployed nano-env" exit 0 else - tags=$(docker images --format '{{.Repository}}:{{.Tag }}' | grep bananocoin | grep -vE "env|ghcr.io|none") + tags=$(docker images --format '{{.Repository}}:{{.Tag }}' | grep bananocoin | grep -vE "env|ghcr.io|none|latest") for a in $tags; do "$scripts"/custom-timeout.sh 30 docker push "$a" done diff --git a/ci/actions/linux/install_deps.sh b/ci/actions/linux/install_deps.sh index 525a46f813..d9d9bc084d 100755 --- a/ci/actions/linux/install_deps.sh +++ b/ci/actions/linux/install_deps.sh @@ -3,5 +3,9 @@ sudo mkdir -p /etc/docker && echo '{"ipv6":true,"fixed-cidr-v6":"2001:db8:1::/64"}' | sudo tee /etc/docker/daemon.json && sudo service docker restart ci/build-docker-image.sh docker/ci/Dockerfile-base bananocoin/nano-env:base -ci/build-docker-image.sh docker/ci/Dockerfile-gcc bananocoin/nano-env:gcc -ci/build-docker-image.sh docker/ci/Dockerfile-clang-6 bananocoin/nano-env:clang-6 +if [[ "${COMPILER:-}" != "" ]]; then + ci/build-docker-image.sh docker/ci/Dockerfile-gcc bananocoin/nano-env:${COMPILER} +else + ci/build-docker-image.sh docker/ci/Dockerfile-gcc nanocurrency/nano-env:gcc + ci/build-docker-image.sh docker/ci/Dockerfile-clang-6 nanocurrency/nano-env:clang-6 +fi diff --git a/ci/actions/windows/build.ps1 b/ci/actions/windows/build.ps1 index a2d65053d8..5001074184 100644 --- a/ci/actions/windows/build.ps1 +++ b/ci/actions/windows/build.ps1 @@ -20,7 +20,7 @@ if (${env:artifact} -eq 1) { $env:RUN = "artifact" } else { - if ( ${env:RELEASE} -eq 1 ) { + if ( ${env:RELEASE} -eq "true" -or ${env:TEST_USE_ROCKSDB} -eq 1 ) { $env:BUILD_TYPE = "RelWithDebInfo" } else { diff --git a/ci/build-centos.sh b/ci/build-centos.sh index 4cebced6d0..8372ba2a5a 100755 --- a/ci/build-centos.sh +++ b/ci/build-centos.sh @@ -1,6 +1,6 @@ #!/usr/bin/env bash TAGS=$(git describe --abbrev=0 --tags) -VERSIONS=$(echo $TAGS | sed 's/V//') +VERSIONS=${TAGS//V/} RELEASE=$(echo $CI_JOB_ID) run_source() { @@ -16,7 +16,7 @@ run_build() { run_update() { for file in ./bananocoin*.in; do - outfile="$(echo "${file}" | sed 's@\.in$@@')" + outfile="${file//.in/}" echo "Updating \"${outfile}\"..." diff --git a/ci/build-docker-image.sh b/ci/build-docker-image.sh index 060dc78bbd..8a8a08e5d3 100755 --- a/ci/build-docker-image.sh +++ b/ci/build-docker-image.sh @@ -1,5 +1,5 @@ #!/bin/bash -set -eu +set -u if [ "$#" -lt 2 ]; then echo 'Usage: build-docker-image.sh [...]' >&2 diff --git a/ci/build-travis.sh b/ci/build-travis.sh index 39fa935509..7b2f225678 100755 --- a/ci/build-travis.sh +++ b/ci/build-travis.sh @@ -28,26 +28,24 @@ fi mkdir build pushd build -if [[ ${RELEASE-0} -eq 1 ]]; then +if [[ "${RELEASE:-false}" == "true" ]]; then BUILD_TYPE="RelWithDebInfo" -else - BUILD_TYPE="Debug" fi -if [[ ${ASAN_INT-0} -eq 1 ]]; then +if [[ ${ASAN_INT:-0} -eq 1 ]]; then SANITIZERS="-DNANO_ASAN_INT=ON" -elif [[ ${ASAN-0} -eq 1 ]]; then +elif [[ ${ASAN:-0} -eq 1 ]]; then SANITIZERS="-DNANO_ASAN=ON" -elif [[ ${TSAN-0} -eq 1 ]]; then +elif [[ ${TSAN:-0} -eq 1 ]]; then SANITIZERS="-DNANO_TSAN=ON" -else - SANITIZERS="" +elif [[ ${LCOV:-0} -eq 1 ]]; then + SANITIZERS="-DCOVERAGE=ON" fi ulimit -S -n 8192 if [[ "$OS" == 'Linux' ]]; then - if clang --version; then + if clang --version && [ ${LCOV:-0} == 0 ]; then BACKTRACE="-DNANO_STACKTRACE_BACKTRACE=ON \ -DBACKTRACE_INCLUDE=" else @@ -64,22 +62,24 @@ cmake \ -DNANO_GUI=ON \ -DPORTABLE=1 \ -DNANO_WARN_TO_ERR=ON \ --DCMAKE_BUILD_TYPE=${BUILD_TYPE} \ +-DCMAKE_BUILD_TYPE=${BUILD_TYPE:-Debug} \ -DCMAKE_VERBOSE_MAKEFILE=ON \ --DBOOST_ROOT=/tmp/boost/ \ +-DBOOST_ROOT=${BOOST_ROOT:-/tmp/boost/} \ -DNANO_SHARED_BOOST=ON \ -DQt5_DIR=${qt_dir} \ -DCI_TEST="1" \ -${BACKTRACE} \ -${SANITIZERS} \ +${BACKTRACE:-} \ +${SANITIZERS:-} \ .. if [[ "$OS" == 'Linux' ]]; then - cmake --build ${PWD} -- -j2 + if [[ ${LCOV:-0} == 1 ]]; then + cmake --build ${PWD} --target generate_coverage -- -j2 + else + cmake --build ${PWD} --target build_tests -k -- -j2 + fi else - sudo cmake --build ${PWD} -- -j2 + sudo cmake --build ${PWD} --target build_tests -- -j2 fi popd - -./ci/test.sh ./build diff --git a/ci/check-cmake-format.sh b/ci/check-cmake-format.sh deleted file mode 100644 index f0bbf478d5..0000000000 --- a/ci/check-cmake-format.sh +++ /dev/null @@ -1,16 +0,0 @@ -#!/bin/bash - -if ! command -v cmake-format &>/dev/null; then - echo "pip install cmake-format and try again" - exit 1 -fi -REPO_ROOT=$(git rev-parse --show-toplevel) -cd "${REPO_ROOT}" -find "${REPO_ROOT}" -iwholename "${REPO_ROOT}/nano/*/CMakeLists.txt" -o -iwholename "${REPO_ROOT}/CMakeLists.txt" | xargs cmake-format --check &>.cmake_format_check -if [[ $(wc -l .cmake_format_check | cut -f1 -d ' ') != 0 ]]; then - echo - echo "Code formatting differs from expected - please run \n\t'bash ci/cmake-format-all.sh'" - RET=1 -fi -rm -fr .cmake_format_check -exit ${RET-0} diff --git a/ci/check-commit-format.sh b/ci/check-commit-format.sh deleted file mode 100755 index 4055ac7bd6..0000000000 --- a/ci/check-commit-format.sh +++ /dev/null @@ -1,16 +0,0 @@ -#!/usr/bin/env bash - -REPO_ROOT=$(git rev-parse --show-toplevel) - -"${REPO_ROOT}/ci/update-clang-format" - -RESULT=$(python $REPO_ROOT/ci/git-clang-format.py --diff -f --commit HEAD~1 --extensions "hpp,cpp") -if [ "$RESULT" != "no modified files to format" ] && [ "$RESULT" != "clang-format did not modify any files" ]; then - python $REPO_ROOT/ci/git-clang-format.py --diff -f --commit HEAD~1 --extensions "hpp,cpp" - echo - echo "Code formatting differs from expected - please run ci/clang-format-all.sh" - exit 1 -else - echo "clang-format passed" - exit 0 -fi diff --git a/ci/clang-format-all.sh b/ci/clang-format-all.sh deleted file mode 100755 index 17661f1912..0000000000 --- a/ci/clang-format-all.sh +++ /dev/null @@ -1,8 +0,0 @@ -#!/bin/bash - -set -e - -REPO_ROOT=$(git rev-parse --show-toplevel) -cd "${REPO_ROOT}" -./ci/update-clang-format -find nano -iname '*.h' -o -iname '*.hpp' -o -iname '*.cpp' | xargs clang-format -i diff --git a/ci/clang-format-check.sh b/ci/clang-format-check.sh new file mode 100755 index 0000000000..358f955fb6 --- /dev/null +++ b/ci/clang-format-check.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash + +################################################################################################### + +source "$(dirname "$BASH_SOURCE")/impl/common.sh" +source "$(dirname "$BASH_SOURCE")/impl/clang-format.sh" + +################################################################################################### + +does_clang_format_exist +if [[ $? == 0 ]]; then + clang_format_check + result=$? + + if [[ $result == 2 ]]; then + exit $result + fi + + if [[ $result == 1 ]]; then + echo "Source code formatting differs from expected - please run ci/clang-format-do.sh" + exit 1 + fi + + echo "clang-format check passed" +fi + +################################################################################################### diff --git a/ci/clang-format-do.sh b/ci/clang-format-do.sh new file mode 100755 index 0000000000..66d9b8ab44 --- /dev/null +++ b/ci/clang-format-do.sh @@ -0,0 +1,15 @@ +#!/usr/bin/env bash + +################################################################################################### + +source "$(dirname "$BASH_SOURCE")/impl/common.sh" +source "$(dirname "$BASH_SOURCE")/impl/clang-format.sh" + +################################################################################################### + +does_clang_format_exist +if [[ $? == 0 ]]; then + clang_format_do +fi + +################################################################################################### diff --git a/ci/cmake-format-all.sh b/ci/cmake-format-all.sh deleted file mode 100755 index 784cf863ce..0000000000 --- a/ci/cmake-format-all.sh +++ /dev/null @@ -1,11 +0,0 @@ -#!/bin/bash - -set -e - -if ! command -v cmake-format &>/dev/null; then - echo "pip install cmake-format to continue" - exit 1 -fi -REPO_ROOT=$(git rev-parse --show-toplevel) -cd "${REPO_ROOT}" -find "${REPO_ROOT}" -iwholename "${REPO_ROOT}/nano/*/CMakeLists.txt" -o -iwholename "${REPO_ROOT}/CMakeLists.txt" | xargs cmake-format -i diff --git a/ci/cmake-format-check.sh b/ci/cmake-format-check.sh new file mode 100755 index 0000000000..c9314a9108 --- /dev/null +++ b/ci/cmake-format-check.sh @@ -0,0 +1,27 @@ +#!/usr/bin/env bash + +################################################################################################### + +source "$(dirname "$BASH_SOURCE")/impl/common.sh" +source "$(dirname "$BASH_SOURCE")/impl/cmake-format.sh" + +################################################################################################### + +does_cmake_format_exist +if [[ $? == 0 ]]; then + cmake_format_check + result=$? + + if [[ $result == 2 ]]; then + exit $result + fi + + if [[ $result == 1 ]]; then + echo "CMake formatting differs from expected - please run ci/cmake-format-do.sh" + exit 1 + fi + + echo "cmake-format check passed" +fi + +################################################################################################### diff --git a/ci/cmake-format-do.sh b/ci/cmake-format-do.sh new file mode 100755 index 0000000000..94f44c34d9 --- /dev/null +++ b/ci/cmake-format-do.sh @@ -0,0 +1,15 @@ +#!/usr/bin/env bash + +################################################################################################### + +source "$(dirname "$BASH_SOURCE")/impl/common.sh" +source "$(dirname "$BASH_SOURCE")/impl/cmake-format.sh" + +################################################################################################### + +does_cmake_format_exist +if [[ $? == 0 ]]; then + cmake_format_do +fi + +################################################################################################### diff --git a/ci/git-clang-format.py b/ci/git-clang-format.py deleted file mode 100644 index a8ae48a0ef..0000000000 --- a/ci/git-clang-format.py +++ /dev/null @@ -1,641 +0,0 @@ -# ============================================================================== -# LLVM Release License -# ============================================================================== -# University of Illinois/NCSA -# Open Source License - -# Copyright (c) 2007-2016 University of Illinois at Urbana-Champaign. -# All rights reserved. - -# Developed by: - -# LLVM Team - -# University of Illinois at Urbana-Champaign - -# http://llvm.org - -# Permission is hereby granted, free of charge, to any person obtaining a copy of -# this software and associated documentation files (the "Software"), to deal with -# the Software without restriction, including without limitation the rights to -# use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies -# of the Software, and to permit persons to whom the Software is furnished to do -# so, subject to the following conditions: - -# * Redistributions of source code must retain the above copyright notice, -# this list of conditions and the following disclaimers. - -# * Redistributions in binary form must reproduce the above copyright notice, -# this list of conditions and the following disclaimers in the -# documentation and/or other materials provided with the distribution. - -# * Neither the names of the LLVM Team, University of Illinois at -# Urbana-Champaign, nor the names of its contributors may be used to -# endorse or promote products derived from this Software without specific -# prior written permission. - -# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR -# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS -# FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE -# CONTRIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER -# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, -# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS WITH THE -# SOFTWARE. - -# ============================================================================== -# The LLVM software contains code written by third parties. Such software will -# have its own individual LICENSE.TXT file in the directory in which it appears. -# This file will describe the copyrights, license, and restrictions which apply -# to that code. - -# The disclaimer of warranty in the University of Illinois Open Source License -# applies to all code in the LLVM Distribution, and nothing in any of the -# other licenses gives permission to use the names of the LLVM Team or the -# University of Illinois to endorse or promote products derived from this -# Software. - -# The following pieces of software have additional or alternate copyrights, -# licenses, and/or restrictions: - -# Program Directory -# ------- --------- -# - -r""" -clang-format git integration -============================ - -This file provides a clang-format integration for git. Put it somewhere in your -path and ensure that it is executable. Then, "git clang-format" will invoke -clang-format on the changes in current files or a specific commit. - -For further details, run: -git clang-format -h - -Requires Python 2.7 or Python 3 -""" - -from __future__ import print_function -import argparse -import collections -import contextlib -import errno -import os -import re -import subprocess -import sys - -usage = 'git clang-format [OPTIONS] [] [] [--] [...]' - -desc = ''' -If zero or one commits are given, run clang-format on all lines that differ -between the working directory and , which defaults to HEAD. Changes are -only applied to the working directory. - -If two commits are given (requires --diff), run clang-format on all lines in the -second that differ from the first . - -The following git-config settings set the default of the corresponding option: - clangFormat.binary - clangFormat.commit - clangFormat.extension - clangFormat.style -''' - -# Name of the temporary index file in which save the output of clang-format. -# This file is created within the .git directory. -temp_index_basename = 'clang-format-index' - - -Range = collections.namedtuple('Range', 'start, count') - - -def main(): - config = load_git_config() - - # In order to keep '--' yet allow options after positionals, we need to - # check for '--' ourselves. (Setting nargs='*' throws away the '--', while - # nargs=argparse.REMAINDER disallows options after positionals.) - argv = sys.argv[1:] - try: - idx = argv.index('--') - except ValueError: - dash_dash = [] - else: - dash_dash = argv[idx:] - argv = argv[:idx] - - default_extensions = ','.join([ - # From clang/lib/Frontend/FrontendOptions.cpp, all lower case - 'c', 'h', # C - 'm', # ObjC - 'mm', # ObjC++ - 'cc', 'cp', 'cpp', 'c++', 'cxx', 'hpp', # C++ - # Other languages that clang-format supports - 'proto', 'protodevel', # Protocol Buffers - 'java', # Java - 'js', # JavaScript - 'ts', # TypeScript - ]) - - p = argparse.ArgumentParser( - usage=usage, formatter_class=argparse.RawDescriptionHelpFormatter, - description=desc) - p.add_argument('--binary', - default=config.get('clangformat.binary', 'clang-format'), - help='path to clang-format'), - p.add_argument('--commit', - default=config.get('clangformat.commit', 'HEAD'), - help='default commit to use if none is specified'), - p.add_argument('--diff', action='store_true', - help='print a diff instead of applying the changes') - p.add_argument('--extensions', - default=config.get('clangformat.extensions', - default_extensions), - help=('comma-separated list of file extensions to format, ' - 'excluding the period and case-insensitive')), - p.add_argument('-f', '--force', action='store_true', - help='allow changes to unstaged files') - p.add_argument('-p', '--patch', action='store_true', - help='select hunks interactively') - p.add_argument('-q', '--quiet', action='count', default=0, - help='print less information') - p.add_argument('--style', - default=config.get('clangformat.style', None), - help='passed to clang-format'), - p.add_argument('-v', '--verbose', action='count', default=0, - help='print extra information') - # We gather all the remaining positional arguments into 'args' since we need - # to use some heuristics to determine whether or not was present. - # However, to print pretty messages, we make use of metavar and help. - p.add_argument('args', nargs='*', metavar='', - help='revision from which to compute the diff') - p.add_argument('ignored', nargs='*', metavar='...', - help='if specified, only consider differences in these files') - opts = p.parse_args(argv) - - opts.verbose -= opts.quiet - del opts.quiet - - commits, files = interpret_args(opts.args, dash_dash, opts.commit) - if len(commits) > 1: - if not opts.diff: - die('--diff is required when two commits are given') - else: - if len(commits) > 2: - die('at most two commits allowed; %d given' % len(commits)) - changed_lines = compute_diff_and_extract_lines(commits, files) - if opts.verbose >= 1: - ignored_files = set(changed_lines) - filter_by_extension(changed_lines, opts.extensions.lower().split(',')) - if opts.verbose >= 1: - ignored_files.difference_update(changed_lines) - if ignored_files: - print('Ignoring changes in the following files (wrong extension):') - for filename in ignored_files: - print(' %s' % filename) - if changed_lines: - print('Running clang-format on the following files:') - for filename in changed_lines: - print(' %s' % filename) - if not changed_lines: - print('no modified files to format') - return - # The computed diff outputs absolute paths, so we must cd before accessing - # those files. - cd_to_toplevel() - if len(commits) > 1: - old_tree = commits[1] - new_tree = run_clang_format_and_save_to_tree(changed_lines, - revision=commits[1], - binary=opts.binary, - style=opts.style) - else: - old_tree = create_tree_from_workdir(changed_lines) - new_tree = run_clang_format_and_save_to_tree(changed_lines, - binary=opts.binary, - style=opts.style) - if opts.verbose >= 1: - print('old tree: %s' % old_tree) - print('new tree: %s' % new_tree) - if old_tree == new_tree: - if opts.verbose >= 0: - print('clang-format did not modify any files') - elif opts.diff: - print_diff(old_tree, new_tree) - else: - changed_files = apply_changes(old_tree, new_tree, force=opts.force, - patch_mode=opts.patch) - if (opts.verbose >= 0 and not opts.patch) or opts.verbose >= 1: - print('changed files:') - for filename in changed_files: - print(' %s' % filename) - - -def load_git_config(non_string_options=None): - """Return the git configuration as a dictionary. - - All options are assumed to be strings unless in `non_string_options`, in which - is a dictionary mapping option name (in lower case) to either "--bool" or - "--int".""" - if non_string_options is None: - non_string_options = {} - out = {} - for entry in run('git', 'config', '--list', '--null').split('\0'): - if entry: - name, value = entry.split('\n', 1) - if name in non_string_options: - value = run('git', 'config', non_string_options[name], name) - out[name] = value - return out - - -def interpret_args(args, dash_dash, default_commit): - """Interpret `args` as "[commits] [--] [files]" and return (commits, files). - - It is assumed that "--" and everything that follows has been removed from - args and placed in `dash_dash`. - - If "--" is present (i.e., `dash_dash` is non-empty), the arguments to its - left (if present) are taken as commits. Otherwise, the arguments are checked - from left to right if they are commits or files. If commits are not given, - a list with `default_commit` is used.""" - if dash_dash: - if len(args) == 0: - commits = [default_commit] - else: - commits = args - for commit in commits: - object_type = get_object_type(commit) - if object_type not in ('commit', 'tag'): - if object_type is None: - die("'%s' is not a commit" % commit) - else: - die("'%s' is a %s, but a commit was expected" % - (commit, object_type)) - files = dash_dash[1:] - elif args: - commits = [] - while args: - if not disambiguate_revision(args[0]): - break - commits.append(args.pop(0)) - if not commits: - commits = [default_commit] - files = args - else: - commits = [default_commit] - files = [] - return commits, files - - -def disambiguate_revision(value): - """Returns True if `value` is a revision, False if it is a file, or dies.""" - # If `value` is ambiguous (neither a commit nor a file), the following - # command will die with an appropriate error message. - run('git', 'rev-parse', value, verbose=False) - object_type = get_object_type(value) - if object_type is None: - return False - if object_type in ('commit', 'tag'): - return True - die('`%s` is a %s, but a commit or filename was expected' % - (value, object_type)) - - -def get_object_type(value): - """Returns a string description of an object's type, or None if it is not - a valid git object.""" - cmd = ['git', 'cat-file', '-t', value] - p = subprocess.Popen(cmd, stdout=subprocess.PIPE, stderr=subprocess.PIPE) - stdout, stderr = p.communicate() - if p.returncode != 0: - return None - return convert_string(stdout.strip()) - - -def compute_diff_and_extract_lines(commits, files): - """Calls compute_diff() followed by extract_lines().""" - diff_process = compute_diff(commits, files) - changed_lines = extract_lines(diff_process.stdout) - diff_process.stdout.close() - diff_process.wait() - if diff_process.returncode != 0: - # Assume error was already printed to stderr. - sys.exit(2) - return changed_lines - - -def compute_diff(commits, files): - """Return a subprocess object producing the diff from `commits`. - - The return value's `stdin` file object will produce a patch with the - differences between the working directory and the first commit if a single - one was specified, or the difference between both specified commits, filtered - on `files` (if non-empty). Zero context lines are used in the patch.""" - git_tool = 'diff-index' - if len(commits) > 1: - git_tool = 'diff-tree' - cmd = ['git', git_tool, '-p', '-U0'] + commits + ['--'] - cmd.extend(files) - p = subprocess.Popen(cmd, stdin=subprocess.PIPE, stdout=subprocess.PIPE) - p.stdin.close() - return p - - -def extract_lines(patch_file): - """Extract the changed lines in `patch_file`. - - The return value is a dictionary mapping filename to a list of (start_line, - line_count) pairs. - - The input must have been produced with ``-U0``, meaning unidiff format with - zero lines of context. The return value is a dict mapping filename to a - list of line `Range`s.""" - matches = {} - for line in patch_file: - line = convert_string(line) - match = re.search(r'^\+\+\+\ [^/]+/(.*)', line) - if match: - filename = match.group(1).rstrip('\r\n') - match = re.search(r'^@@ -[0-9,]+ \+(\d+)(,(\d+))?', line) - if match: - start_line = int(match.group(1)) - line_count = 1 - if match.group(3): - line_count = int(match.group(3)) - if line_count > 0: - matches.setdefault(filename, []).append( - Range(start_line, line_count)) - return matches - - -def filter_by_extension(dictionary, allowed_extensions): - """Delete every key in `dictionary` that doesn't have an allowed extension. - - `allowed_extensions` must be a collection of lowercase file extensions, - excluding the period.""" - allowed_extensions = frozenset(allowed_extensions) - for filename in list(dictionary.keys()): - base_ext = filename.rsplit('.', 1) - if len(base_ext) == 1 and '' in allowed_extensions: - continue - if len(base_ext) == 1 or base_ext[1].lower() not in allowed_extensions: - del dictionary[filename] - - -def cd_to_toplevel(): - """Change to the top level of the git repository.""" - toplevel = run('git', 'rev-parse', '--show-toplevel') - os.chdir(toplevel) - - -def create_tree_from_workdir(filenames): - """Create a new git tree with the given files from the working directory. - - Returns the object ID (SHA-1) of the created tree.""" - return create_tree(filenames, '--stdin') - - -def run_clang_format_and_save_to_tree(changed_lines, revision=None, - binary='clang-format', style=None): - """Run clang-format on each file and save the result to a git tree. - - Returns the object ID (SHA-1) of the created tree.""" - def iteritems(container): - try: - return container.iteritems() # Python 2 - except AttributeError: - return container.items() # Python 3 - - def index_info_generator(): - for filename, line_ranges in iteritems(changed_lines): - if revision: - git_metadata_cmd = ['git', 'ls-tree', - '%s:%s' % ( - revision, os.path.dirname(filename)), - os.path.basename(filename)] - git_metadata = subprocess.Popen(git_metadata_cmd, stdin=subprocess.PIPE, - stdout=subprocess.PIPE) - stdout = git_metadata.communicate()[0] - mode = oct(int(stdout.split()[0], 8)) - else: - mode = oct(os.stat(filename).st_mode) - # Adjust python3 octal format so that it matches what git expects - if mode.startswith('0o'): - mode = '0' + mode[2:] - blob_id = clang_format_to_blob(filename, line_ranges, - revision=revision, - binary=binary, - style=style) - yield '%s %s\t%s' % (mode, blob_id, filename) - return create_tree(index_info_generator(), '--index-info') - - -def create_tree(input_lines, mode): - """Create a tree object from the given input. - - If mode is '--stdin', it must be a list of filenames. If mode is - '--index-info' is must be a list of values suitable for "git update-index - --index-info", such as " ". Any other mode - is invalid.""" - assert mode in ('--stdin', '--index-info') - cmd = ['git', 'update-index', '--add', '-z', mode] - with temporary_index_file(): - p = subprocess.Popen(cmd, stdin=subprocess.PIPE) - for line in input_lines: - p.stdin.write(to_bytes('%s\0' % line)) - p.stdin.close() - if p.wait() != 0: - die('`%s` failed' % ' '.join(cmd)) - tree_id = run('git', 'write-tree') - return tree_id - - -def clang_format_to_blob(filename, line_ranges, revision=None, - binary='clang-format', style=None): - """Run clang-format on the given file and save the result to a git blob. - - Runs on the file in `revision` if not None, or on the file in the working - directory if `revision` is None. - - Returns the object ID (SHA-1) of the created blob.""" - clang_format_cmd = [binary] - if style: - clang_format_cmd.extend(['-style='+style]) - clang_format_cmd.extend([ - '-lines=%s:%s' % (start_line, start_line+line_count-1) - for start_line, line_count in line_ranges]) - if revision: - clang_format_cmd.extend(['-assume-filename='+filename]) - git_show_cmd = ['git', 'cat-file', 'blob', - '%s:%s' % (revision, filename)] - git_show = subprocess.Popen(git_show_cmd, stdin=subprocess.PIPE, - stdout=subprocess.PIPE) - git_show.stdin.close() - clang_format_stdin = git_show.stdout - else: - clang_format_cmd.extend([filename]) - git_show = None - clang_format_stdin = subprocess.PIPE - try: - clang_format = subprocess.Popen(clang_format_cmd, stdin=clang_format_stdin, - stdout=subprocess.PIPE) - if clang_format_stdin == subprocess.PIPE: - clang_format_stdin = clang_format.stdin - except OSError as e: - if e.errno == errno.ENOENT: - die('cannot find executable "%s"' % binary) - else: - raise - clang_format_stdin.close() - hash_object_cmd = ['git', 'hash-object', - '-w', '--path='+filename, '--stdin'] - hash_object = subprocess.Popen(hash_object_cmd, stdin=clang_format.stdout, - stdout=subprocess.PIPE) - clang_format.stdout.close() - stdout = hash_object.communicate()[0] - if hash_object.returncode != 0: - die('`%s` failed' % ' '.join(hash_object_cmd)) - if clang_format.wait() != 0: - die('`%s` failed' % ' '.join(clang_format_cmd)) - if git_show and git_show.wait() != 0: - die('`%s` failed' % ' '.join(git_show_cmd)) - return convert_string(stdout).rstrip('\r\n') - - -@contextlib.contextmanager -def temporary_index_file(tree=None): - """Context manager for setting GIT_INDEX_FILE to a temporary file and deleting - the file afterward.""" - index_path = create_temporary_index(tree) - old_index_path = os.environ.get('GIT_INDEX_FILE') - os.environ['GIT_INDEX_FILE'] = index_path - try: - yield - finally: - if old_index_path is None: - del os.environ['GIT_INDEX_FILE'] - else: - os.environ['GIT_INDEX_FILE'] = old_index_path - os.remove(index_path) - - -def create_temporary_index(tree=None): - """Create a temporary index file and return the created file's path. - - If `tree` is not None, use that as the tree to read in. Otherwise, an - empty index is created.""" - gitdir = run('git', 'rev-parse', '--git-dir') - path = os.path.join(gitdir, temp_index_basename) - if tree is None: - tree = '--empty' - run('git', 'read-tree', '--index-output='+path, tree) - return path - - -def print_diff(old_tree, new_tree): - """Print the diff between the two trees to stdout.""" - # We use the porcelain 'diff' and not plumbing 'diff-tree' because the output - # is expected to be viewed by the user, and only the former does nice things - # like color and pagination. - # - # We also only print modified files since `new_tree` only contains the files - # that were modified, so unmodified files would show as deleted without the - # filter. - subprocess.check_call(['git', 'diff', '--diff-filter=M', old_tree, new_tree, - '--']) - - -def apply_changes(old_tree, new_tree, force=False, patch_mode=False): - """Apply the changes in `new_tree` to the working directory. - - Bails if there are local changes in those files and not `force`. If - `patch_mode`, runs `git checkout --patch` to select hunks interactively.""" - changed_files = run('git', 'diff-tree', '--diff-filter=M', '-r', '-z', - '--name-only', old_tree, - new_tree).rstrip('\0').split('\0') - if not force: - unstaged_files = run('git', 'diff-files', - '--name-status', *changed_files) - if unstaged_files: - print('The following files would be modified but ' - 'have unstaged changes:', file=sys.stderr) - print(unstaged_files, file=sys.stderr) - print('Please commit, stage, or stash them first.', file=sys.stderr) - sys.exit(2) - if patch_mode: - # In patch mode, we could just as well create an index from the new tree - # and checkout from that, but then the user will be presented with a - # message saying "Discard ... from worktree". Instead, we use the old - # tree as the index and checkout from new_tree, which gives the slightly - # better message, "Apply ... to index and worktree". This is not quite - # right, since it won't be applied to the user's index, but oh well. - with temporary_index_file(old_tree): - subprocess.check_call(['git', 'checkout', '--patch', new_tree]) - index_tree = old_tree - else: - with temporary_index_file(new_tree): - run('git', 'checkout-index', '-a', '-f') - return changed_files - - -def run(*args, **kwargs): - stdin = kwargs.pop('stdin', '') - verbose = kwargs.pop('verbose', True) - strip = kwargs.pop('strip', True) - for name in kwargs: - raise TypeError("run() got an unexpected keyword argument '%s'" % name) - p = subprocess.Popen(args, stdout=subprocess.PIPE, stderr=subprocess.PIPE, - stdin=subprocess.PIPE) - stdout, stderr = p.communicate(input=stdin) - - stdout = convert_string(stdout) - stderr = convert_string(stderr) - - if p.returncode == 0: - if stderr: - if verbose: - print('`%s` printed to stderr:' % - ' '.join(args), file=sys.stderr) - print(stderr.rstrip(), file=sys.stderr) - if strip: - stdout = stdout.rstrip('\r\n') - return stdout - if verbose: - print('`%s` returned %s' % - (' '.join(args), p.returncode), file=sys.stderr) - if stderr: - print(stderr.rstrip(), file=sys.stderr) - sys.exit(2) - - -def die(message): - print('error:', message, file=sys.stderr) - sys.exit(2) - - -def to_bytes(str_input): - # Encode to UTF-8 to get binary data. - if isinstance(str_input, bytes): - return str_input - return str_input.encode('utf-8') - - -def to_string(bytes_input): - if isinstance(bytes_input, str): - return bytes_input - return bytes_input.encode('utf-8') - - -def convert_string(bytes_input): - try: - return to_string(bytes_input.decode('utf-8')) - except AttributeError: # 'str' object has no attribute 'decode'. - return str(bytes_input) - except UnicodeError: - return str(bytes_input) - - -if __name__ == '__main__': - main() diff --git a/ci/impl/clang-format.sh b/ci/impl/clang-format.sh new file mode 100644 index 0000000000..3a3d69626e --- /dev/null +++ b/ci/impl/clang-format.sh @@ -0,0 +1,102 @@ +#!/usr/bin/env bash + +################################################################################################### + +CLANG_FORMAT="" +CLANG_FORMAT_VERSION="12" + +################################################################################################### + +does_clang_format_exist() +{ + local attempts=("clang-format" "clang-format-$CLANG_FORMAT_VERSION") + for itr in ${attempts[@]}; do + version=$(_is_clang_format_usable $itr $CLANG_FORMAT_VERSION) + if [[ $? == 1 ]]; then + continue + fi + + if [[ $? == 0 ]]; then + CLANG_FORMAT=$itr + break + fi + + echo "Detected '$itr' with version '$version' " \ + "(different than '$CLANG_FORMAT_VERSION'), skipping it." + done + + if [[ -z $CLANG_FORMAT ]]; then + echo "No 'clang-format' of version '$CLANG_FORMAT_VERSION' could be detected in your " \ + "PATH. Try 'sudo apt-get install clang-format-$CLANG_FORMAT_VERSION' or, if macOS, " \ + "'brew install clang-format'. Or up/down grade, if installed differently." + return 1 + fi + + echo "Using '$CLANG_FORMAT' version '$CLANG_FORMAT_VERSION'" + return 0 +} + +################################################################################################### + +clang_format_do() +{ + _clang_format_perform "do" +} + +################################################################################################### + +clang_format_check() +{ + _clang_format_perform "check" +} + +################################################################################################### + +_is_clang_format_usable() +{ + if [[ $(builtin type -p $1) ]]; then + local output=$($1 --version) + if [[ $output =~ ^(.)*$2(.)*$ ]]; then + return 0 + fi + + echo $output + return 1 + fi + + return 2 +} + +################################################################################################### + +_clang_format_perform() +{ + if [[ -z "$CLANG_FORMAT" ]]; then + echo "Logic error: '_lang_format_perform' called, but 'CLANG_FORMAT' " \ + "is empty. Have you called 'does_clang_format_exist'?" + return 2 + fi + + find "$ROOTPATH/nano" -type f \( -iname "*.hpp" \ + -o \ + -iname "*.cpp" \ + \) \ + -print0 | + while read -d $'\0' file + do + if [[ $1 == "do" ]]; then + "$CLANG_FORMAT" -i "$file" + elif [[ $1 == "check" ]]; then + "$CLANG_FORMAT" -style=file -Werror --dry-run "$file" + if [[ $? != 0 ]]; then + return 1 + fi + else + echo "Logic error: '_clang_format_perform' called " \ + "with neither 'do' nor 'check' as argument, but '$1'" + return 2 + fi + done +} + +################################################################################################### diff --git a/ci/impl/cmake-format.sh b/ci/impl/cmake-format.sh new file mode 100644 index 0000000000..9a8c187319 --- /dev/null +++ b/ci/impl/cmake-format.sh @@ -0,0 +1,108 @@ +#!/usr/bin/env bash + +################################################################################################### + +CMAKE_FORMAT="" +CMAKE_FORMAT_VERSION="0.6.13" + +################################################################################################### + +does_cmake_format_exist() +{ + local attempts=("cmake-format") + for itr in ${attempts[@]}; do + version=$(_is_cmake_format_usable $itr $CMAKE_FORMAT_VERSION) + if [[ $? == 1 ]]; then + continue + fi + + if [[ $? == 0 ]]; then + CMAKE_FORMAT=$itr + break + fi + + echo "Detected '$itr' with version '$version' " \ + "(different than '$CMAKE_FORMAT_VERSION'), skipping it." + done + + if [[ -z $CMAKE_FORMAT ]]; then + echo "No 'cmake-format' of version '$CMAKE_FORMAT_VERSION' could be detected in your " \ + "PATH. Try 'pip3 install cmake-format'. Or up/down grade, if installed differently." + return 1 + fi + + echo "Using '$CMAKE_FORMAT' version '$CMAKE_FORMAT_VERSION'" + return 0 +} + +################################################################################################### + +cmake_format_do() +{ + _cmake_format_perform "do" +} + +################################################################################################### + +cmake_format_check() +{ + _cmake_format_perform "check" +} + +################################################################################################### + +_is_cmake_format_usable() +{ + if [[ $(builtin type -p $1) ]]; then + local output=$($1 --version) + if [[ $output =~ ^(.)*$2(.)*$ ]]; then + return 0 + fi + + echo $output + return 1 + fi + + return 2 +} + +################################################################################################### + +_cmake_format_perform() +{ + if [[ -z "$CMAKE_FORMAT" ]]; then + echo "Logic error: '_cmake_format_perform' called, but 'CMAKE_FORMAT' " \ + "is empty. Have you called 'does_cmake_format_exist'?" + return 2 + fi + + find "$ROOTPATH" -type f \( -iwholename "$ROOTPATH/CMakeLists.txt" \ + -o \ + -iwholename "$ROOTPATH/coverage/CMakeLists.txt" \ + -o \ + -iwholename "$ROOTPATH/nano/*/CMakeLists.txt" \ + \) \ + -print0 | + while read -d $'\0' file + do + if [[ $1 == "do" ]]; then + "$CMAKE_FORMAT" -i "$file" + elif [[ $1 == "check" ]]; then + "$CMAKE_FORMAT" "$file" -o tmp + + diff "$file" tmp > /dev/null + if [[ $? != 0 ]]; then + rm tmp + return 1 + fi + + rm tmp + else + echo "Logic error: '_cmake_format_perform' called " \ + "with neither 'do' nor 'check' as argument, but '$1'" + return 2 + fi + done +} + +################################################################################################### diff --git a/ci/impl/common.sh b/ci/impl/common.sh new file mode 100644 index 0000000000..dc97b26204 --- /dev/null +++ b/ci/impl/common.sh @@ -0,0 +1,7 @@ +#!/usr/bin/env bash + +################################################################################################### + +ROOTPATH="$(git rev-parse --show-toplevel)" + +################################################################################################### diff --git a/ci/test.sh b/ci/test.sh index 1982c126f2..f7226dcefb 100755 --- a/ci/test.sh +++ b/ci/test.sh @@ -2,9 +2,9 @@ build_dir=${1-${PWD}} if [[ ${TEST_USE_ROCKSDB-0} == 1 ]]; then - TIMEOUT_DEFAULT=720 + TIMEOUT_DEFAULT=1440 else - TIMEOUT_DEFAULT=360 + TIMEOUT_DEFAULT=720 fi BUSYBOX_BASH=${BUSYBOX_BASH-0} @@ -23,61 +23,52 @@ set -o nounset set -o xtrace # Alpine doesn't offer an xvfb -xvfb_run_() { +xvfb_run_() +{ INIT_DELAY_SEC=3 Xvfb :2 -screen 0 1024x768x24 & xvfb_pid=$! sleep ${INIT_DELAY_SEC} - DISPLAY=:2 ${TIMEOUT_CMD} ${TIMEOUT_TIME_ARG} ${TIMEOUT_SEC-${TIMEOUT_DEFAULT}} $@ + DISPLAY=:2 ${TIMEOUT_CMD} ${TIMEOUT_TIME_ARG} ${TIMEOUT_DEFAULT} $@ res=${?} kill ${xvfb_pid} return ${res} } -run_tests() { - local tries try - - # when busybox pretends to be bash it needs different args - # for the timeout builtin +run_tests() +{ + # when busybox pretends to be bash it needs different args for the timeout builtin + # if [[ "${BUSYBOX_BASH}" -eq 1 ]]; then TIMEOUT_TIME_ARG="-t" else TIMEOUT_TIME_ARG="" fi - tries=(_initial_) - - for try in "${tries[@]}"; do - if [ "${try}" != '_initial_' ]; then - echo "core_test failed: ${core_test_res}, retrying (try=${try})" - - # Wait a while for sockets to be all cleaned up by the kernel - sleep $((30 + (RANDOM % 30))) - fi + ${TIMEOUT_CMD} ${TIMEOUT_TIME_ARG} ${TIMEOUT_DEFAULT} ./core_test + core_test_res=${?} - ${TIMEOUT_CMD} ${TIMEOUT_TIME_ARG} ${TIMEOUT_SEC-${TIMEOUT_DEFAULT}} ./core_test - core_test_res=${?} - if [ "${core_test_res}" = '0' ]; then - break - fi - done - - xvfb_run_ ./rpc_test + ${TIMEOUT_CMD} ${TIMEOUT_TIME_ARG} ${TIMEOUT_DEFAULT} ./rpc_test rpc_test_res=${?} xvfb_run_ ./qt_test qt_test_res=${?} - ${TIMEOUT_CMD} ${TIMEOUT_TIME_ARG} ${TIMEOUT_SEC-${TIMEOUT_DEFAULT}} ./load_test -s 150 -n 5 - load_test_res=${?} + (cd ../systest && export NANO_NODE_EXE=../build/nano_node && ${TIMEOUT_CMD} ${TIMEOUT_TIME_ARG} 300 ./RUNALL) + sys_test_res=${?} echo "Core Test return code: ${core_test_res}" echo "RPC Test return code: ${rpc_test_res}" echo "QT Test return code: ${qt_test_res}" - echo "Load Test return code: ${load_test_res}" - return ${core_test_res} + echo "Sys Test return code: ${sys_test_res}" + + if [[ ${core_test_res} != 0 || ${rpc_test_res} != 0 || ${qt_test_res} != 0 || ${sys_test_res} != 0 ]]; then + return 1 + else + return 0 + fi } cd ${build_dir} diff --git a/ci/update-clang-format b/ci/update-clang-format deleted file mode 100755 index 4c28567740..0000000000 --- a/ci/update-clang-format +++ /dev/null @@ -1,39 +0,0 @@ -#! /usr/bin/env bash - -ci_dir="$(dirname "${BASH_SOURCE[0]}")" - -set -e - -cd "${ci_dir}/.." - -retval='1' - -rm -f .clang-format -cp .clang-format.base .clang-format -for try in {1..10}; do - errors="$(clang-format -dump-config 2>&1 >/dev/null)" || : - if [ -z "${errors}" ]; then - retval='0' - - break - fi - - errors_line="$(echo "${errors}" | awk ' - /^YAML:/{ - sub(/^YAML:/, ""); - sub(/:.*/, ""); - print; - exit; - } - ')" - - if ! [ "${errors_line}" -gt -1 ] 2>/dev/null; then - break - fi - - rm -f .clang-format.new - sed "${errors_line} d" .clang-format >.clang-format.new - mv .clang-format.new .clang-format -done - -exit "${retval}" diff --git a/cmake/Modules/CoverageTest.cmake b/cmake/Modules/CoverageTest.cmake new file mode 100644 index 0000000000..df15e1174c --- /dev/null +++ b/cmake/Modules/CoverageTest.cmake @@ -0,0 +1,23 @@ +set(CMAKE_CXX_FLAGS "${CMAKE_CXX_FLAGS} -fprofile-arcs -ftest-coverage") +set(CMAKE_EXE_LINKER_FLAGS "${CMAKE_EXE_LINKER_FLAGS} --coverage -lgcov") +find_program(LCOV_PATH lcov) +message("lcov found: ${LCOV_PATH}") +find_program(GENHTML_PATH genhtml) +message("genhtml found: ${GENHTML_PATH}") +if(NOT CMAKE_COMPILER_IS_GNUCXX) + # Clang version 3.0.0 and greater now supports gcov as well. + message( + WARNING + "Compiler is not GNU gcc! Clang Version 3.0.0 and greater supports gcov as well, but older versions don't." + ) + if(NOT "${CMAKE_CXX_COMPILER_ID}" STREQUAL "Clang") + message(FATAL_ERROR "Compiler is not GNU gcc! Aborting...") + endif() +endif() +if(NOT (CMAKE_BUILD_TYPE STREQUAL "Debug" OR CMAKE_BUILD_TYPE STREQUAL + "Coverage")) + message( + WARNING + "Code coverage results with an optimized (non-Debug) build may be misleading" + ) +endif() \ No newline at end of file diff --git a/coverage/CMakeLists.txt b/coverage/CMakeLists.txt new file mode 100644 index 0000000000..8f1e6143bc --- /dev/null +++ b/coverage/CMakeLists.txt @@ -0,0 +1,51 @@ +add_custom_target( + clean_coverage + COMMAND echo "CLEANING COUNTERS" + COMMAND ${LCOV_PATH} --directory . --zerocounter -q + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + DEPENDS build_tests) + +add_custom_target( + coverage_tests + COMMAND echo "RUN TESTS FOR COVERAGE" + COMMAND ${PROJECT_SOURCE_DIR}/ci/test.sh ${CMAKE_BINARY_DIR} || true + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + DEPENDS clean_coverage) + +add_custom_target( + coveralls_upload + COMMAND echo "UPLOADING COVERALLS COVERAGE REPORT" + COMMAND coveralls -i nano -b build -r . --gcov-options '\\-lp' + WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} + DEPENDS coverage_tests) + +add_custom_target( + generate_coverage + COMMAND echo "CAPTURING COVERAGE DATA" + COMMAND ${LCOV_PATH} --directory . --capture --output-file lcov.info.raw -q + COMMAND echo "REMOVING FLUFF FROM REPORT" + COMMAND + ${LCOV_PATH} --remove lcov.info.raw '/usr/*' '/tmp/*' + '${PROJECT_SOURCE_DIR}/cpptoml/*' '${PROJECT_SOURCE_DIR}/crypto/*' + '${PROJECT_SOURCE_DIR}/flatbuffers/*' '${PROJECT_SOURCE_DIR}/gtest/*' + '${PROJECT_SOURCE_DIR}/rocksdb/*' '${PROJECT_SOURCE_DIR}/valgrind/*' + '${PROJECT_SOURCE_DIR}/nano/core_test/*' '${PROJECT_SOURCE_DIR}/diskhash/*' + '${PROJECT_SOURCE_DIR}/nano/load_test/*' + '${PROJECT_SOURCE_DIR}/nano/ipc_flatbuffers_test/*' + '${PROJECT_SOURCE_DIR}/nano/ipc_flatbuffers_lib/*' + '${PROJECT_SOURCE_DIR}/nano/nano_node/*' + '${PROJECT_SOURCE_DIR}/nano/nano_wallet/*' + '${PROJECT_SOURCE_DIR}/nano/nano_rpc/*' + '${PROJECT_SOURCE_DIR}/nano/rpc_test/*' + '${PROJECT_SOURCE_DIR}/nano/qt_test/*' '${PROJECT_SOURCE_DIR}/nano/qt/*' + '${PROJECT_SOURCE_DIR}/nano/test_common/*' --output-file + ${PROJECT_SOURCE_DIR}/coverage/lcov.info -q + WORKING_DIRECTORY ${CMAKE_BINARY_DIR} + DEPENDS coverage_tests) + +add_custom_target( + generate_html + COMMAND echo "GENERATING HTML COVERAGE REPORT" + COMMAND ${GENHTML_PATH} -o coverage ${PROJECT_SOURCE_DIR}/coverage/lcov.info + WORKING_DIRECTORY ${PROJECT_SOURCE_DIR} + DEPENDS generate_coverage) diff --git a/crypto/cryptopp b/crypto/cryptopp index 1c34979592..f2102243e6 160000 --- a/crypto/cryptopp +++ b/crypto/cryptopp @@ -1 +1 @@ -Subproject commit 1c34979592f7d5e5d73e265a9c8650cc006620d2 +Subproject commit f2102243e6fdd48c0b2a393a0993cca228f20573 diff --git a/diskhash b/diskhash new file mode 160000 index 0000000000..0b81937e1b --- /dev/null +++ b/diskhash @@ -0,0 +1 @@ +Subproject commit 0b81937e1b9f48885c254f534dcfddf124b65c2f diff --git a/docker/ci/Dockerfile-gcc b/docker/ci/Dockerfile-gcc index 2bad5b9ee5..65960198f7 100644 --- a/docker/ci/Dockerfile-gcc +++ b/docker/ci/Dockerfile-gcc @@ -1,6 +1,6 @@ FROM nanocurrency/nano-env:base -RUN apt-get install -yqq git +RUN apt update -qq && apt-get install -yqq git ENV BOOST_ROOT=/tmp/boost diff --git a/flatbuffers b/flatbuffers index 3b458f7a17..a9a295fecf 160000 --- a/flatbuffers +++ b/flatbuffers @@ -1 +1 @@ -Subproject commit 3b458f7a170154ed4c4a3a2a9f6116fb2d415ad5 +Subproject commit a9a295fecf3fbd5a4f571f53b01f63202a3e2113 diff --git a/gtest b/gtest index 703bd9caab..e2239ee604 160000 --- a/gtest +++ b/gtest @@ -1 +1 @@ -Subproject commit 703bd9caab50b139428cea1aaff9974ebee5742e +Subproject commit e2239ee6043f73722e7aa812a459f54a28552929 diff --git a/images/logo.svg b/images/logo.svg index 95d96fb9a9..6808294ea7 100644 --- a/images/logo.svg +++ b/images/logo.svg @@ -1 +1,9 @@ - \ No newline at end of file + + + + + + + + + diff --git a/miniupnp b/miniupnp index 81029a860b..2df8120326 160000 --- a/miniupnp +++ b/miniupnp @@ -1 +1 @@ -Subproject commit 81029a860baf1f727903e5b85307903b3f40cbc8 +Subproject commit 2df8120326ed4246e049a7a6de707539604cd514 diff --git a/nano/boost/asio/ip/network_v6.hpp b/nano/boost/asio/ip/network_v6.hpp new file mode 100644 index 0000000000..b9f213ab63 --- /dev/null +++ b/nano/boost/asio/ip/network_v6.hpp @@ -0,0 +1,7 @@ +#pragma once + +#include + +DISABLE_ASIO_WARNINGS +#include +REENABLE_WARNINGS diff --git a/nano/core_test/CMakeLists.txt b/nano/core_test/CMakeLists.txt index 51b55a32c6..27838e67f6 100644 --- a/nano/core_test/CMakeLists.txt +++ b/nano/core_test/CMakeLists.txt @@ -6,6 +6,7 @@ add_executable( active_transactions.cpp block.cpp block_store.cpp + blockprocessor.cpp bootstrap.cpp cli.cpp confirmation_height.cpp @@ -20,6 +21,7 @@ add_executable( gap_cache.cpp ipc.cpp ledger.cpp + ledger_walker.cpp locks.cpp logger.cpp message.cpp @@ -35,6 +37,7 @@ add_executable( signal_manager.cpp signing.cpp socket.cpp + system.cpp telemetry.cpp toml.cpp timer.cpp diff --git a/nano/core_test/active_transactions.cpp b/nano/core_test/active_transactions.cpp index f4b49e60a9..f5fb079ae0 100644 --- a/nano/core_test/active_transactions.cpp +++ b/nano/core_test/active_transactions.cpp @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include @@ -11,19 +11,21 @@ using namespace std::chrono_literals; namespace nano { -TEST (active_transactions, confirm_active) +// Test disabled because it's failing intermittently. +// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3512 +// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3522 +TEST (active_transactions, DISABLED_confirm_active) { nano::system system; nano::node_flags node_flags; node_flags.disable_request_loop = true; auto & node1 = *system.add_node (node_flags); - nano::genesis genesis; auto send = nano::send_block_builder () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (nano::public_key ()) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1.process (*send).code); nano::node_config node_config2 (nano::get_available_port (), system.logging); @@ -43,15 +45,15 @@ TEST (active_transactions, confirm_active) auto election = node2.active.election (send->qualified_root ()); ASSERT_NE (nullptr, election); // Add key to node1 - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // Add representative to disabled rep crawler auto peers (node2.network.random_set (1)); ASSERT_FALSE (peers.empty ()); { nano::lock_guard guard (node2.rep_crawler.probable_reps_mutex); - node2.rep_crawler.probable_reps.emplace (nano::dev_genesis_key.pub, nano::genesis_amount, *peers.begin ()); + node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, *peers.begin ()); } - ASSERT_TIMELY (5s, election->votes ().size () != 1); // Votes were inserted (except for not_an_account) + ASSERT_TIMELY (5s, election->votes ().size () != 1); // Votes were inserted (except for the null account) auto confirm_req_count (election->confirmation_request_count.load ()); // At least one confirmation request ASSERT_GT (confirm_req_count, 0u); @@ -63,7 +65,7 @@ TEST (active_transactions, confirm_active) ASSERT_TIMELY (10s, node2.ledger.cache.cemented_count == 2 && node2.active.empty ()); // At least one more confirmation request ASSERT_GT (election->confirmation_request_count, confirm_req_count); - // Blocks were cleared (except for not_an_account) + // Blocks were cleared (except for the null account) ASSERT_EQ (1, election->blocks ().size ()); } } @@ -83,25 +85,24 @@ TEST (active_transactions, confirm_frontier) auto & node2 = *system.add_node (node_flags2); // Add key to node1 - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // Add representative to disabled rep crawler auto peers (node2.network.random_set (1)); ASSERT_FALSE (peers.empty ()); { nano::lock_guard guard (node2.rep_crawler.probable_reps_mutex); - node2.rep_crawler.probable_reps.emplace (nano::dev_genesis_key.pub, nano::genesis_amount, *peers.begin ()); + node2.rep_crawler.probable_reps.emplace (nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, *peers.begin ()); } - nano::genesis genesis; nano::state_block_builder builder; auto send = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 100) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 100) .link (nano::public_key ()) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto send_copy = builder.make_block ().from (*send).build_shared (); ASSERT_EQ (nano::process_result::progress, node1.process (*send).code); @@ -127,16 +128,15 @@ TEST (active_transactions, keep_local) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node = *system.add_node (node_config); auto & wallet (*system.wallet (0)); - nano::genesis genesis; //key 1/2 will be managed by the wallet nano::keypair key1, key2, key3, key4, key5, key6; - wallet.insert_adhoc (nano::dev_genesis_key.prv); - auto send1 (wallet.send_action (nano::dev_genesis_key.pub, key1.pub, node.config.receive_minimum.number ())); - auto send2 (wallet.send_action (nano::dev_genesis_key.pub, key2.pub, node.config.receive_minimum.number ())); - auto send3 (wallet.send_action (nano::dev_genesis_key.pub, key3.pub, node.config.receive_minimum.number ())); - auto send4 (wallet.send_action (nano::dev_genesis_key.pub, key4.pub, node.config.receive_minimum.number ())); - auto send5 (wallet.send_action (nano::dev_genesis_key.pub, key5.pub, node.config.receive_minimum.number ())); - auto send6 (wallet.send_action (nano::dev_genesis_key.pub, key6.pub, node.config.receive_minimum.number ())); + wallet.insert_adhoc (nano::dev::genesis_key.prv); + auto send1 (wallet.send_action (nano::dev::genesis_key.pub, key1.pub, node.config.receive_minimum.number ())); + auto send2 (wallet.send_action (nano::dev::genesis_key.pub, key2.pub, node.config.receive_minimum.number ())); + auto send3 (wallet.send_action (nano::dev::genesis_key.pub, key3.pub, node.config.receive_minimum.number ())); + auto send4 (wallet.send_action (nano::dev::genesis_key.pub, key4.pub, node.config.receive_minimum.number ())); + auto send5 (wallet.send_action (nano::dev::genesis_key.pub, key5.pub, node.config.receive_minimum.number ())); + auto send6 (wallet.send_action (nano::dev::genesis_key.pub, key6.pub, node.config.receive_minimum.number ())); // should not drop wallet created transactions ASSERT_TIMELY (5s, node.active.size () == 1); for (auto const & block : { send1, send2, send3, send4, send5, send6 }) @@ -188,16 +188,16 @@ TEST (active_transactions, inactive_votes_cache) { nano::system system (1); auto & node = *system.nodes[0]; - nano::block_hash latest (node.latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node.latest (nano::dev::genesis_key.pub)); nano::keypair key; auto send = nano::send_block_builder () .previous (latest) .destination (key.pub) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); - auto vote (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), std::vector (1, send->hash ()))); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector (1, send->hash ()))); node.vote_processor.vote (vote, std::make_shared (node)); ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 1); node.process_active (send); @@ -210,16 +210,16 @@ TEST (active_transactions, inactive_votes_cache_non_final) { nano::system system (1); auto & node = *system.nodes[0]; - nano::block_hash latest (node.latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node.latest (nano::dev::genesis_key.pub)); nano::keypair key; auto send = nano::send_block_builder () .previous (latest) .destination (key.pub) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); - auto vote (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, std::vector (1, send->hash ()))); // Non-final vote + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector (1, send->hash ()))); // Non-final vote node.vote_processor.vote (vote, std::make_shared (node)); ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 1); node.process_active (send); @@ -228,39 +228,39 @@ TEST (active_transactions, inactive_votes_cache_non_final) auto election = node.active.election (send->qualified_root ()); ASSERT_NE (nullptr, election); ASSERT_FALSE (election->confirmed ()); - ASSERT_EQ (nano::genesis_amount - 100, election->tally ().begin ()->first); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, election->tally ().begin ()->first); } TEST (active_transactions, inactive_votes_cache_fork) { nano::system system (1); auto & node = *system.nodes[0]; - nano::block_hash latest (node.latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node.latest (nano::dev::genesis_key.pub)); nano::keypair key; nano::send_block_builder builder; auto send1 = builder.make_block () .previous (latest) .destination (key.pub) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); auto send2 = builder.make_block () .previous (latest) .destination (key.pub) - .balance (nano::genesis_amount - 200) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 200) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); - auto vote (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), std::vector (1, send1->hash ()))); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector (1, send1->hash ()))); node.vote_processor.vote (vote, std::make_shared (node)); auto channel1 (node.network.udp_channels.create (node.network.endpoint ())); ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 1); - node.network.process_message (nano::publish (send2), channel1); + node.network.inbound (nano::publish{ nano::dev::network_params.network, send2 }, channel1); node.block_processor.flush (); ASSERT_NE (nullptr, node.block (send2->hash ())); node.scheduler.flush (); // Start election, otherwise conflicting block won't be inserted into election - node.network.process_message (nano::publish (send1), channel1); + node.network.inbound (nano::publish{ nano::dev::network_params.network, send1 }, channel1); node.block_processor.flush (); bool confirmed (false); system.deadline_set (5s); @@ -279,14 +279,14 @@ TEST (active_transactions, inactive_votes_cache_existing_vote) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node = *system.add_node (node_config); - nano::block_hash latest (node.latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node.latest (nano::dev::genesis_key.pub)); nano::keypair key; nano::block_builder builder; auto send = builder.send () .previous (latest) .destination (key.pub) - .balance (nano::genesis_amount - 100 * nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 100 * nano::MBAN_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); auto open = builder.state () @@ -306,13 +306,13 @@ TEST (active_transactions, inactive_votes_cache_existing_vote) ASSERT_NE (nullptr, election); ASSERT_GT (node.weight (key.pub), node.minimum_principal_weight ()); // Insert vote - auto vote1 (std::make_shared (key.pub, key.prv, 1, std::vector (1, send->hash ()))); + auto vote1 (std::make_shared (key.pub, key.prv, nano::vote::timestamp_min * 1, 0, std::vector (1, send->hash ()))); node.vote_processor.vote (vote1, std::make_shared (node)); ASSERT_TIMELY (5s, election->votes ().size () == 2); ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::vote_new)); auto last_vote1 (election->votes ()[key.pub]); ASSERT_EQ (send->hash (), last_vote1.hash); - ASSERT_EQ (1, last_vote1.timestamp); + ASSERT_EQ (nano::vote::timestamp_min * 1, last_vote1.timestamp); // Attempt to change vote with inactive_votes_cache nano::unique_lock active_lock (node.active.mutex); node.active.add_inactive_votes_cache (active_lock, send->hash (), key.pub, 0); @@ -336,21 +336,21 @@ TEST (active_transactions, inactive_votes_cache_multiple_votes) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node = *system.add_node (node_config); - nano::block_hash latest (node.latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node.latest (nano::dev::genesis_key.pub)); nano::keypair key1; nano::block_builder builder; auto send1 = builder.send () .previous (latest) .destination (key1.pub) - .balance (nano::genesis_amount - 100 * nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 100 * nano::MBAN_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); auto send2 = builder.send () .previous (send1->hash ()) .destination (key1.pub) .balance (100 * nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); auto open = builder.state () @@ -367,13 +367,13 @@ TEST (active_transactions, inactive_votes_cache_multiple_votes) node.block_processor.add (open); node.block_processor.flush (); // Process votes - auto vote1 (std::make_shared (key1.pub, key1.prv, 0, std::vector (1, send1->hash ()))); + auto vote1 (std::make_shared (key1.pub, key1.prv, 0, 0, std::vector (1, send1->hash ()))); node.vote_processor.vote (vote1, std::make_shared (node)); - auto vote2 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, std::vector (1, send1->hash ()))); + auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector (1, send1->hash ()))); node.vote_processor.vote (vote2, std::make_shared (node)); ASSERT_TIMELY (5s, node.active.find_inactive_votes_cache (send1->hash ()).voters.size () == 2); ASSERT_EQ (1, node.active.inactive_votes_cache_size ()); - node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ()); + node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); node.scheduler.flush (); auto election = node.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election); @@ -387,22 +387,22 @@ TEST (active_transactions, inactive_votes_cache_election_start) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node = *system.add_node (node_config); - nano::block_hash latest (node.latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node.latest (nano::dev::genesis_key.pub)); nano::keypair key1, key2; nano::send_block_builder send_block_builder; nano::state_block_builder state_block_builder; auto send1 = send_block_builder.make_block () .previous (latest) .destination (key1.pub) - .balance (nano::genesis_amount - 5000 * nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 5000 * nano::MBAN_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); auto send2 = send_block_builder.make_block () .previous (send1->hash ()) .destination (key2.pub) - .balance (nano::genesis_amount - 10000 * nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 10000 * nano::MBAN_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); auto open1 = state_block_builder.make_block () @@ -436,30 +436,30 @@ TEST (active_transactions, inactive_votes_cache_election_start) .previous (send2->hash ()) .destination (nano::keypair ().pub) .balance (send2->balance ().number () - 1) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build_shared (); auto send4 = send_block_builder.make_block () .previous (send3->hash ()) .destination (nano::keypair ().pub) .balance (send3->balance ().number () - 1) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send3->hash ())) .build_shared (); // Inactive votes std::vector hashes{ open1->hash (), open2->hash (), send4->hash () }; - auto vote1 (std::make_shared (key1.pub, key1.prv, 0, hashes)); + auto vote1 (std::make_shared (key1.pub, key1.prv, 0, 0, hashes)); node.vote_processor.vote (vote1, std::make_shared (node)); ASSERT_TIMELY (5s, node.active.inactive_votes_cache_size () == 3); ASSERT_TRUE (node.active.empty ()); ASSERT_EQ (1, node.ledger.cache.cemented_count); // 2 votes are required to start election (dev network) - auto vote2 (std::make_shared (key2.pub, key2.prv, 0, hashes)); + auto vote2 (std::make_shared (key2.pub, key2.prv, 0, 0, hashes)); node.vote_processor.vote (vote2, std::make_shared (node)); // Only open1 & open2 blocks elections should start (send4 is missing previous block in ledger) ASSERT_TIMELY (5s, 2 == node.active.size ()); // Confirm elections with weight quorum - auto vote0 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), hashes)); // Final vote for confirmation + auto vote0 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, hashes)); // Final vote for confirmation node.vote_processor.vote (vote0, std::make_shared (node)); ASSERT_TIMELY (5s, node.active.empty ()); ASSERT_TIMELY (5s, 5 == node.ledger.cache.cemented_count); @@ -492,17 +492,16 @@ TEST (active_transactions, vote_replays) node_config.enable_voting = false; node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node = *system.add_node (node_config); - nano::genesis genesis; nano::keypair key; nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_NE (nullptr, send1); auto open1 = builder.make_block () @@ -520,7 +519,7 @@ TEST (active_transactions, vote_replays) nano::blocks_confirm (node, { send1, open1 }); ASSERT_EQ (2, node.active.size ()); // First vote is not a replay and confirms the election, second vote should be a replay since the election has confirmed but not yet removed - auto vote_send1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), send1)); + auto vote_send1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, send1)); ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_send1)); ASSERT_EQ (2, node.active.size ()); ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_send1)); @@ -528,9 +527,8 @@ TEST (active_transactions, vote_replays) ASSERT_TIMELY (3s, node.active.size () == 1); ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_send1)); // Open new account - auto vote_open1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), open1)); + auto vote_open1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, open1)); ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote_open1)); - ASSERT_EQ (1, node.active.size ()); ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_open1)); ASSERT_TIMELY (3s, node.active.empty ()); ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote_open1)); @@ -549,8 +547,8 @@ TEST (active_transactions, vote_replays) node.process_active (send2); nano::blocks_confirm (node, { send2 }); ASSERT_EQ (1, node.active.size ()); - auto vote1_send2 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), send2)); - auto vote2_send2 (std::make_shared (key.pub, key.prv, 0, send2)); + auto vote1_send2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, send2)); + auto vote2_send2 (std::make_shared (key.pub, key.prv, 0, 0, send2)); ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote2_send2)); ASSERT_EQ (1, node.active.size ()); ASSERT_EQ (nano::vote_code::replay, node.active.vote (vote2_send2)); @@ -583,31 +581,27 @@ TEST (active_transactions, dropped_cleanup) flags.disable_request_loop = true; auto & node (*system.add_node (flags)); - nano::genesis genesis; - auto block = genesis.open; - block->sideband_set (nano::block_sideband (nano::genesis_account, 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); - // Add to network filter to ensure proper cleanup after the election is dropped std::vector block_bytes; { nano::vectorstream stream (block_bytes); - block->serialize (stream); + nano::dev::genesis->serialize (stream); } ASSERT_FALSE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ())); ASSERT_TRUE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ())); - node.block_confirm (block); + node.block_confirm (nano::dev::genesis); node.scheduler.flush (); - auto election = node.active.election (block->qualified_root ()); + auto election = node.active.election (nano::dev::genesis->qualified_root ()); ASSERT_NE (nullptr, election); // Not yet removed ASSERT_TRUE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ())); - ASSERT_EQ (1, node.active.blocks.count (block->hash ())); + ASSERT_EQ (1, node.active.blocks.count (nano::dev::genesis->hash ())); // Now simulate dropping the election ASSERT_FALSE (election->confirmed ()); - node.active.erase (*block); + node.active.erase (*nano::dev::genesis); // The filter must have been cleared ASSERT_FALSE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ())); @@ -616,17 +610,17 @@ TEST (active_transactions, dropped_cleanup) ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::election_drop_all)); // Block cleared from active - ASSERT_EQ (0, node.active.blocks.count (block->hash ())); + ASSERT_EQ (0, node.active.blocks.count (nano::dev::genesis->hash ())); // Repeat test for a confirmed election ASSERT_TRUE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ())); - node.block_confirm (block); + node.block_confirm (nano::dev::genesis); node.scheduler.flush (); - election = node.active.election (block->qualified_root ()); + election = node.active.election (nano::dev::genesis->qualified_root ()); ASSERT_NE (nullptr, election); election->force_confirm (); ASSERT_TRUE (election->confirmed ()); - node.active.erase (*block); + node.active.erase (*nano::dev::genesis); // The filter should not have been cleared ASSERT_TRUE (node.network.publish_filter.apply (block_bytes.data (), block_bytes.size ())); @@ -635,7 +629,7 @@ TEST (active_transactions, dropped_cleanup) ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::election_drop_all)); // Block cleared from active - ASSERT_EQ (0, node.active.blocks.count (block->hash ())); + ASSERT_EQ (0, node.active.blocks.count (nano::dev::genesis->hash ())); } TEST (active_transactions, republish_winner) @@ -647,17 +641,16 @@ TEST (active_transactions, republish_winner) node_config.peering_port = nano::get_available_port (); auto & node2 = *system.add_node (node_config); - nano::genesis genesis; nano::keypair key; nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node1.process_active (send1); @@ -668,13 +661,13 @@ TEST (active_transactions, republish_winner) for (auto i (0); i < 5; i++) { auto fork = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 1 - i) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 1 - i) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node1.process_active (fork); } @@ -684,20 +677,20 @@ TEST (active_transactions, republish_winner) // Process new fork with vote to change winner auto fork = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node1.process_active (fork); node1.block_processor.flush (); auto election = node1.active.election (fork->qualified_root ()); ASSERT_NE (nullptr, election); - auto vote = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), std::vector{ fork->hash () }); + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector{ fork->hash () }); node1.vote_processor.vote (vote, std::make_shared (node1)); node1.vote_processor.flush (); node1.block_processor.flush (); @@ -713,17 +706,16 @@ TEST (active_transactions, fork_filter_cleanup) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node1 (*system.add_node (node_config)); - nano::genesis genesis; nano::keypair key; nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); std::vector block_bytes; { @@ -735,13 +727,13 @@ TEST (active_transactions, fork_filter_cleanup) for (auto i (0); i < 10; i++) { auto fork = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 1 - i) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 1 - i) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node1.process_active (fork); node1.block_processor.flush (); @@ -772,12 +764,11 @@ TEST (active_transactions, fork_replacement_tally) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node1 (*system.add_node (node_config)); - nano::genesis genesis; size_t reps_count = 20; size_t const max_blocks = 10; std::vector keys (reps_count); - auto latest (genesis.hash ()); - auto balance (nano::genesis_amount); + auto latest (nano::dev::genesis->hash ()); + auto balance (nano::dev::constants.genesis_amount); auto amount (node1.minimum_principal_weight ()); nano::state_block_builder builder; @@ -786,12 +777,12 @@ TEST (active_transactions, fork_replacement_tally) { balance -= amount + i; auto send = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (latest) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (balance) .link (keys[i].pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); node1.process_active (send); @@ -807,7 +798,7 @@ TEST (active_transactions, fork_replacement_tally) .build_shared (); node1.process_active (open); // Confirmation - auto vote (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), std::vector{ send->hash (), open->hash () })); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector{ send->hash (), open->hash () })); node1.vote_processor.vote (vote, std::make_shared (node1)); } node1.block_processor.flush (); @@ -815,12 +806,12 @@ TEST (active_transactions, fork_replacement_tally) nano::keypair key; auto send_last = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (latest) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (balance - 2 * nano::MBAN_ratio) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); @@ -828,12 +819,12 @@ TEST (active_transactions, fork_replacement_tally) for (auto i (0); i < reps_count; i++) { auto fork = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (latest) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (balance - nano::MBAN_ratio - i) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); node1.process_active (fork); @@ -849,15 +840,15 @@ TEST (active_transactions, fork_replacement_tally) for (auto i (0); i < reps_count; i++) { auto fork = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (latest) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (balance - 1 - i) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (latest)) .build_shared (); - auto vote (std::make_shared (keys[i].pub, keys[i].prv, 0, std::vector{ fork->hash () })); + auto vote (std::make_shared (keys[i].pub, keys[i].prv, 0, 0, std::vector{ fork->hash () })); node1.vote_processor.vote (vote, std::make_shared (node1)); node1.vote_processor.flush (); node1.process_active (fork); @@ -887,7 +878,7 @@ TEST (active_transactions, fork_replacement_tally) ASSERT_FALSE (blocks1.find (send_last->hash ()) != blocks1.end ()); // Process vote for correct block & replace existing lowest tally block - auto vote (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, std::vector{ send_last->hash () })); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ send_last->hash () })); node1.vote_processor.vote (vote, std::make_shared (node1)); node1.vote_processor.flush (); node2.network.flood_block (send_last); @@ -906,7 +897,7 @@ TEST (active_transactions, fork_replacement_tally) } ASSERT_FALSE (votes2.find (keys[max_blocks].pub) != votes2.end ()); ASSERT_FALSE (votes2.find (keys[max_blocks + 1].pub) != votes2.end ()); - ASSERT_TRUE (votes2.find (nano::dev_genesis_key.pub) != votes2.end ()); + ASSERT_TRUE (votes2.find (nano::dev::genesis_key.pub) != votes2.end ()); } namespace nano @@ -918,15 +909,15 @@ TEST (active_transactions, confirmation_consistency) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node = *system.add_node (node_config); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); for (unsigned i = 0; i < 10; ++i) { - auto block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::public_key (), node.config.receive_minimum.number ())); + auto block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::public_key (), node.config.receive_minimum.number ())); ASSERT_NE (nullptr, block); system.deadline_set (5s); while (!node.ledger.block_confirmed (node.store.tx_begin_read (), block->hash ())) { - node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ()); + node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); ASSERT_NO_ERROR (system.poll (5ms)); } ASSERT_NO_ERROR (system.poll_until_true (1s, [&node, &block, i] { @@ -943,13 +934,12 @@ TEST (active_transactions, confirm_new) { nano::system system (1); auto & node1 = *system.nodes[0]; - nano::genesis genesis; auto send = nano::send_block_builder () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (nano::public_key ()) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node1.process_active (send); node1.block_processor.flush (); @@ -957,70 +947,13 @@ TEST (active_transactions, confirm_new) ASSERT_EQ (1, node1.active.size ()); auto & node2 = *system.add_node (); // Add key to node2 - system.wallet (1)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); // Let node2 know about the block ASSERT_TIMELY (5s, node2.block (send->hash ())); // Wait confirmation ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 2 && node2.ledger.cache.cemented_count == 2); } -TEST (active_transactions, restart_dropped) -{ - nano::system system; - nano::node_config node_config (nano::get_available_port (), system.logging); - node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; - auto & node = *system.add_node (node_config); - nano::genesis genesis; - auto send = nano::state_block_builder () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::RAW_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) - .build_shared (); // Process only in ledger and simulate dropping the election - ASSERT_EQ (nano::process_result::progress, node.process (*send).code); - // Generate higher difficulty work - ASSERT_TRUE (node.work_generate_blocking (*send, send->difficulty () + 1).is_initialized ()); - // Process the same block with updated work - ASSERT_EQ (0, node.active.size ()); - node.process_active (send); - node.block_processor.flush (); - node.scheduler.flush (); - ASSERT_EQ (1, node.active.size ()); - ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::election_restart)); - auto ledger_block (node.store.block_get (node.store.tx_begin_read (), send->hash ())); - ASSERT_NE (nullptr, ledger_block); - // Exact same block, including work value must have been re-written - ASSERT_EQ (*send, *ledger_block); - // Drop election - node.active.erase (*send); - ASSERT_EQ (0, node.active.size ()); - // Try to restart election with the same difficulty - node.process_active (send); - node.block_processor.flush (); - node.scheduler.flush (); - ASSERT_EQ (0, node.active.size ()); - ASSERT_EQ (1, node.stats.count (nano::stat::type::election, nano::stat::detail::election_restart)); - // Generate even higher difficulty work - ASSERT_TRUE (node.work_generate_blocking (*send, send->difficulty () + 1).is_initialized ()); - // Add voting - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - // Process the same block with updated work - ASSERT_EQ (0, node.active.size ()); - node.process_active (send); - node.block_processor.flush (); - node.scheduler.flush (); - ASSERT_EQ (1, node.active.size ()); - ASSERT_EQ (1, node.ledger.cache.cemented_count); - ASSERT_EQ (2, node.stats.count (nano::stat::type::election, nano::stat::detail::election_restart)); - // Wait for the election to complete - ASSERT_TIMELY (5s, node.ledger.cache.cemented_count == 2); - // Verify the block is eventually updated in the ledger - ASSERT_TIMELY (3s, node.store.block_get (node.store.tx_begin_read (), send->hash ())->block_work () == send->block_work ()); -} - // Ensures votes are tallied on election::publish even if no vote is inserted through inactive_votes_cache TEST (active_transactions, conflicting_block_vote_existing_election) { @@ -1028,28 +961,27 @@ TEST (active_transactions, conflicting_block_vote_existing_election) nano::node_flags node_flags; node_flags.disable_request_loop = true; auto & node = *system.add_node (node_flags); - nano::genesis genesis; nano::keypair key; nano::state_block_builder builder; auto send = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 100) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 100) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto fork = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 200) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 200) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - auto vote_fork (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), fork)); + auto vote_fork (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, fork)); ASSERT_EQ (nano::process_result::progress, node.process_local (send).code); node.scheduler.flush (); @@ -1078,30 +1010,30 @@ TEST (active_transactions, activate_account_chain) nano::keypair key; nano::state_block_builder builder; auto send = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) - .link (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 1) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .link (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); auto send2 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send->hash ()) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .link (key.pub) - .balance (nano::genesis_amount - 2) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) .build (); auto send3 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send2->hash ()) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .link (key.pub) - .balance (nano::genesis_amount - 3) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 3) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build (); auto open = builder.make_block () @@ -1128,19 +1060,19 @@ TEST (active_transactions, activate_account_chain) ASSERT_EQ (nano::process_result::progress, node.process (*open).code); ASSERT_EQ (nano::process_result::progress, node.process (*receive).code); - node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ()); + node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); node.scheduler.flush (); auto election1 = node.active.election (send->qualified_root ()); ASSERT_EQ (1, node.active.size ()); ASSERT_EQ (1, election1->blocks ().count (send->hash ())); - node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ()); + node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); auto election2 = node.active.election (send->qualified_root ()); ASSERT_EQ (election2, election1); election1->force_confirm (); ASSERT_TIMELY (3s, node.block_confirmed (send->hash ())); // On cementing, the next election is started ASSERT_TIMELY (3s, node.active.active (send2->qualified_root ())); - node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ()); + node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); auto election3 = node.active.election (send2->qualified_root ()); ASSERT_NE (nullptr, election3); ASSERT_EQ (1, election3->blocks ().count (send2->hash ())); @@ -1149,7 +1081,7 @@ TEST (active_transactions, activate_account_chain) // On cementing, the next election is started ASSERT_TIMELY (3s, node.active.active (open->qualified_root ())); ASSERT_TIMELY (3s, node.active.active (send3->qualified_root ())); - node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ()); + node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); auto election4 = node.active.election (send3->qualified_root ()); ASSERT_NE (nullptr, election4); ASSERT_EQ (1, election4->blocks ().count (send3->hash ())); @@ -1178,21 +1110,21 @@ TEST (active_transactions, activate_inactive) nano::keypair key; nano::state_block_builder builder; auto send = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .link (key.pub) - .balance (nano::genesis_amount - 1) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .balance (nano::dev::constants.genesis_amount - 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto send2 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send->hash ()) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .link (nano::keypair ().pub) - .balance (nano::genesis_amount - 2) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) .build_shared (); auto open = builder.make_block () @@ -1239,24 +1171,24 @@ TEST (active_transactions, pessimistic_elections) nano::keypair key; nano::state_block_builder builder; auto send = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) - .link (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 1) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .link (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.process (*send).code); auto send2 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send->hash ()) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .link (key.pub) - .balance (nano::genesis_amount - 2) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) .build (); @@ -1290,7 +1222,7 @@ TEST (active_transactions, pessimistic_elections) ASSERT_EQ (2, node.active.expired_optimistic_election_infos.size ()); ASSERT_EQ (2, node.active.expired_optimistic_election_infos.size ()); auto election_started_it = node.active.expired_optimistic_election_infos.get ().begin (); - ASSERT_EQ (election_started_it->account, nano::genesis_account); + ASSERT_EQ (election_started_it->account, nano::dev::genesis->account ()); ASSERT_EQ (election_started_it->election_started, true); ASSERT_EQ ((++election_started_it)->election_started, false); @@ -1311,14 +1243,14 @@ TEST (active_transactions, pessimistic_elections) nano::confirmation_height_info key1_confirmation_height_info; { auto transaction = node.store.tx_begin_read (); - node.store.confirmation_height_get (transaction, nano::genesis_account, genesis_confirmation_height_info); + node.store.confirmation_height.get (transaction, nano::dev::genesis->account (), genesis_confirmation_height_info); ASSERT_EQ (2, genesis_confirmation_height_info.height); - node.store.confirmation_height_get (transaction, key.pub, key1_confirmation_height_info); + node.store.confirmation_height.get (transaction, key.pub, key1_confirmation_height_info); ASSERT_EQ (0, key1_confirmation_height_info.height); } // Activation of cemented frontier successor should get started after the first pessimistic block is confirmed - ASSERT_TIMELY (10s, node.active.active (send->qualified_root ())); + ASSERT_TIMELY (10s, node.active.active (send2->qualified_root ())); node.active.confirm_expired_frontiers_pessimistically (node.store.tx_begin_read (), 100, election_count); ASSERT_EQ (1, election_count); @@ -1333,9 +1265,9 @@ TEST (active_transactions, pessimistic_elections) { auto transaction = node.store.tx_begin_read (); - node.store.confirmation_height_get (transaction, nano::genesis_account, genesis_confirmation_height_info); + node.store.confirmation_height.get (transaction, nano::dev::genesis->account (), genesis_confirmation_height_info); ASSERT_EQ (3, genesis_confirmation_height_info.height); - node.store.confirmation_height_get (transaction, key.pub, key1_confirmation_height_info); + node.store.confirmation_height.get (transaction, key.pub, key1_confirmation_height_info); ASSERT_EQ (0, key1_confirmation_height_info.height); } @@ -1357,9 +1289,9 @@ TEST (active_transactions, pessimistic_elections) { auto transaction = node.store.tx_begin_read (); - node.store.confirmation_height_get (transaction, nano::genesis_account, genesis_confirmation_height_info); + node.store.confirmation_height.get (transaction, nano::dev::genesis->account (), genesis_confirmation_height_info); ASSERT_EQ (3, genesis_confirmation_height_info.height); - node.store.confirmation_height_get (transaction, key.pub, key1_confirmation_height_info); + node.store.confirmation_height.get (transaction, key.pub, key1_confirmation_height_info); ASSERT_EQ (1, key1_confirmation_height_info.height); } @@ -1378,24 +1310,24 @@ TEST (active_transactions, list_active) nano::keypair key; nano::state_block_builder builder; auto send = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) - .link (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 1) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .link (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.process (*send).code); auto send2 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send->hash ()) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .link (key.pub) - .balance (nano::genesis_amount - 2) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) .build_shared (); @@ -1433,20 +1365,20 @@ TEST (active_transactions, vacancy) auto & node = *system.add_node (config); nano::state_block_builder builder; auto send = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) - .link (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .link (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); std::atomic updated = false; node.active.vacancy_update = [&updated] () { updated = true; }; ASSERT_EQ (nano::process_result::progress, node.process (*send).code); ASSERT_EQ (1, node.active.vacancy ()); ASSERT_EQ (0, node.active.size ()); - node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ()); + node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); ASSERT_TIMELY (1s, updated); updated = false; ASSERT_EQ (0, node.active.vacancy ()); @@ -1471,25 +1403,25 @@ TEST (active_transactions, fifo) nano::state_block_builder builder; // Construct two pending entries that can be received simultaneously auto send0 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .link (key0.pub) - .balance (nano::genesis_amount - 1) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .balance (nano::dev::constants.genesis_amount - 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.process (*send0).code); nano::blocks_confirm (node, { send0 }, true); ASSERT_TIMELY (1s, node.block_confirmed (send0->hash ())); ASSERT_TIMELY (1s, node.active.empty ()); auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send0->hash ()) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .link (key1.pub) - .balance (nano::genesis_amount - 2) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send0->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.process (*send1).code); @@ -1500,7 +1432,7 @@ TEST (active_transactions, fifo) auto receive0 = builder.make_block () .account (key0.pub) .previous (0) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .link (send0->hash ()) .balance (1) .sign (key0.prv, key0.pub) @@ -1510,7 +1442,7 @@ TEST (active_transactions, fifo) auto receive1 = builder.make_block () .account (key1.pub) .previous (0) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .link (send1->hash ()) .balance (1) .sign (key1.prv, key1.pub) diff --git a/nano/core_test/block.cpp b/nano/core_test/block.cpp index a29438c8dd..7834e59b57 100644 --- a/nano/core_test/block.cpp +++ b/nano/core_test/block.cpp @@ -270,7 +270,7 @@ TEST (change_block, deserialize) TEST (frontier_req, serialization) { - nano::frontier_req request1; + nano::frontier_req request1{ nano::dev::network_params.network }; request1.start = 1; request1.age = 2; request1.count = 3; @@ -293,7 +293,7 @@ TEST (block, publish_req_serialization) nano::keypair key1; nano::keypair key2; auto block (std::make_shared (0, key2.pub, 200, nano::keypair ().prv, 2, 3)); - nano::publish req (block); + nano::publish req{ nano::dev::network_params.network, block }; std::vector bytes; { nano::vectorstream stream (bytes); @@ -312,7 +312,7 @@ TEST (block, publish_req_serialization) TEST (block, difficulty) { nano::send_block block (0, 1, 2, nano::keypair ().prv, 4, 5); - ASSERT_EQ (block.difficulty (), nano::work_difficulty (block.work_version (), block.root (), block.block_work ())); + ASSERT_EQ (nano::dev::network_params.work.difficulty (block), nano::dev::network_params.work.difficulty (block.work_version (), block.root (), block.block_work ())); } TEST (state_block, serialization) @@ -630,7 +630,7 @@ TEST (block_builder, open) .representative_address ("ban_1bananobh5rat99qfgt1ptpieie5swmoth87thi74qgbfrij7dcgjiij94xr") .source_hex ("2514452A978F08D1CF76BB40B6AD064183CF275D3CC5D3E0515DC96E2112AD4E") .build (ec); - ASSERT_EQ (block->hash ().to_string (), "991CF190094C00F0B68E2E5F75F6BEE95A2E0BD93CEAA4A6734DB9F19B728948"); + ASSERT_EQ (block->hash ().to_string (), "F61A79F286ABC5CC01D3D09686F0567812B889A5C63ADE0E82DD30F3B2D96463"); ASSERT_EQ (block->source ().to_string (), "2514452A978F08D1CF76BB40B6AD064183CF275D3CC5D3E0515DC96E2112AD4E"); ASSERT_TRUE (block->destination ().is_zero ()); ASSERT_TRUE (block->link ().is_zero ()); @@ -710,7 +710,7 @@ TEST (block_builder, send) .build (ec); ASSERT_EQ (block->hash ().to_string (), "4560E7B1F3735D082700CFC2852F5D1F378F7418FD24CEF1AD45AB69316F15CD"); ASSERT_TRUE (block->source ().is_zero ()); - ASSERT_EQ (block->destination ().to_account (), "nano_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb"); + ASSERT_EQ (block->destination ().to_account (), "ban_1gys8r4crpxhp94n4uho5cshaho81na6454qni5gu9n53gksoyy1wcd4udyb"); ASSERT_TRUE (block->link ().is_zero ()); } diff --git a/nano/core_test/block_store.cpp b/nano/core_test/block_store.cpp index 4c525adf96..b15efe1a6c 100644 --- a/nano/core_test/block_store.cpp +++ b/nano/core_test/block_store.cpp @@ -7,10 +7,10 @@ #include #include #include -#include #include #include #include +#include #include #include @@ -34,7 +34,7 @@ void write_block_w_sideband_v18 (nano::mdb_store & store_a, MDB_dbi database, na TEST (block_store, construction) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); } @@ -109,53 +109,53 @@ TEST (block_store, sideband_serialization) TEST (block_store, add_item) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::open_block block (0, 1, 0, nano::keypair ().prv, 0, 0); block.sideband_set ({}); auto hash1 (block.hash ()); auto transaction (store->tx_begin_write ()); - auto latest1 (store->block_get (transaction, hash1)); + auto latest1 (store->block.get (transaction, hash1)); ASSERT_EQ (nullptr, latest1); - ASSERT_FALSE (store->block_exists (transaction, hash1)); - store->block_put (transaction, hash1, block); - auto latest2 (store->block_get (transaction, hash1)); + ASSERT_FALSE (store->block.exists (transaction, hash1)); + store->block.put (transaction, hash1, block); + auto latest2 (store->block.get (transaction, hash1)); ASSERT_NE (nullptr, latest2); ASSERT_EQ (block, *latest2); - ASSERT_TRUE (store->block_exists (transaction, hash1)); - ASSERT_FALSE (store->block_exists (transaction, hash1.number () - 1)); - store->block_del (transaction, hash1); - auto latest3 (store->block_get (transaction, hash1)); + ASSERT_TRUE (store->block.exists (transaction, hash1)); + ASSERT_FALSE (store->block.exists (transaction, hash1.number () - 1)); + store->block.del (transaction, hash1); + auto latest3 (store->block.get (transaction, hash1)); ASSERT_EQ (nullptr, latest3); } TEST (block_store, clear_successor) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::open_block block1 (0, 1, 0, nano::keypair ().prv, 0, 0); block1.sideband_set ({}); auto transaction (store->tx_begin_write ()); - store->block_put (transaction, block1.hash (), block1); + store->block.put (transaction, block1.hash (), block1); nano::open_block block2 (0, 2, 0, nano::keypair ().prv, 0, 0); block2.sideband_set ({}); - store->block_put (transaction, block2.hash (), block2); - auto block2_store (store->block_get (transaction, block1.hash ())); + store->block.put (transaction, block2.hash (), block2); + auto block2_store (store->block.get (transaction, block1.hash ())); ASSERT_NE (nullptr, block2_store); ASSERT_EQ (0, block2_store->sideband ().successor.number ()); auto modified_sideband = block2_store->sideband (); modified_sideband.successor = block2.hash (); block1.sideband_set (modified_sideband); - store->block_put (transaction, block1.hash (), block1); + store->block.put (transaction, block1.hash (), block1); { - auto block1_store (store->block_get (transaction, block1.hash ())); + auto block1_store (store->block.get (transaction, block1.hash ())); ASSERT_NE (nullptr, block1_store); ASSERT_EQ (block2.hash (), block1_store->sideband ().successor); } - store->block_successor_clear (transaction, block1.hash ()); + store->block.successor_clear (transaction, block1.hash ()); { - auto block1_store (store->block_get (transaction, block1.hash ())); + auto block1_store (store->block.get (transaction, block1.hash ())); ASSERT_NE (nullptr, block1_store); ASSERT_EQ (0, block1_store->sideband ().successor.number ()); } @@ -164,7 +164,7 @@ TEST (block_store, clear_successor) TEST (block_store, add_nonempty_block) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key1; nano::open_block block (0, 1, 0, nano::keypair ().prv, 0, 0); @@ -172,10 +172,10 @@ TEST (block_store, add_nonempty_block) auto hash1 (block.hash ()); block.signature = nano::sign_message (key1.prv, key1.pub, hash1); auto transaction (store->tx_begin_write ()); - auto latest1 (store->block_get (transaction, hash1)); + auto latest1 (store->block.get (transaction, hash1)); ASSERT_EQ (nullptr, latest1); - store->block_put (transaction, hash1, block); - auto latest2 (store->block_get (transaction, hash1)); + store->block.put (transaction, hash1, block); + auto latest2 (store->block.get (transaction, hash1)); ASSERT_NE (nullptr, latest2); ASSERT_EQ (block, *latest2); } @@ -183,7 +183,7 @@ TEST (block_store, add_nonempty_block) TEST (block_store, add_two_items) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key1; nano::open_block block (0, 1, 1, nano::keypair ().prv, 0, 0); @@ -191,21 +191,21 @@ TEST (block_store, add_two_items) auto hash1 (block.hash ()); block.signature = nano::sign_message (key1.prv, key1.pub, hash1); auto transaction (store->tx_begin_write ()); - auto latest1 (store->block_get (transaction, hash1)); + auto latest1 (store->block.get (transaction, hash1)); ASSERT_EQ (nullptr, latest1); nano::open_block block2 (0, 1, 3, nano::keypair ().prv, 0, 0); block2.sideband_set ({}); block2.hashables.account = 3; auto hash2 (block2.hash ()); block2.signature = nano::sign_message (key1.prv, key1.pub, hash2); - auto latest2 (store->block_get (transaction, hash2)); + auto latest2 (store->block.get (transaction, hash2)); ASSERT_EQ (nullptr, latest2); - store->block_put (transaction, hash1, block); - store->block_put (transaction, hash2, block2); - auto latest3 (store->block_get (transaction, hash1)); + store->block.put (transaction, hash1, block); + store->block.put (transaction, hash2, block2); + auto latest3 (store->block.get (transaction, hash1)); ASSERT_NE (nullptr, latest3); ASSERT_EQ (block, *latest3); - auto latest4 (store->block_get (transaction, hash2)); + auto latest4 (store->block.get (transaction, hash2)); ASSERT_NE (nullptr, latest4); ASSERT_EQ (block2, *latest4); ASSERT_FALSE (*latest3 == *latest4); @@ -214,21 +214,21 @@ TEST (block_store, add_two_items) TEST (block_store, add_receive) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key1; nano::keypair key2; nano::open_block block1 (0, 1, 0, nano::keypair ().prv, 0, 0); block1.sideband_set ({}); auto transaction (store->tx_begin_write ()); - store->block_put (transaction, block1.hash (), block1); + store->block.put (transaction, block1.hash (), block1); nano::receive_block block (block1.hash (), 1, nano::keypair ().prv, 2, 3); block.sideband_set ({}); nano::block_hash hash1 (block.hash ()); - auto latest1 (store->block_get (transaction, hash1)); + auto latest1 (store->block.get (transaction, hash1)); ASSERT_EQ (nullptr, latest1); - store->block_put (transaction, hash1, block); - auto latest2 (store->block_get (transaction, hash1)); + store->block.put (transaction, hash1, block); + auto latest2 (store->block.get (transaction, hash1)); ASSERT_NE (nullptr, latest2); ASSERT_EQ (block, *latest2); } @@ -236,31 +236,31 @@ TEST (block_store, add_receive) TEST (block_store, add_pending) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key1; nano::pending_key key2 (0, 0); nano::pending_info pending1; auto transaction (store->tx_begin_write ()); - ASSERT_TRUE (store->pending_get (transaction, key2, pending1)); - store->pending_put (transaction, key2, pending1); + ASSERT_TRUE (store->pending.get (transaction, key2, pending1)); + store->pending.put (transaction, key2, pending1); nano::pending_info pending2; - ASSERT_FALSE (store->pending_get (transaction, key2, pending2)); + ASSERT_FALSE (store->pending.get (transaction, key2, pending2)); ASSERT_EQ (pending1, pending2); - store->pending_del (transaction, key2); - ASSERT_TRUE (store->pending_get (transaction, key2, pending2)); + store->pending.del (transaction, key2); + ASSERT_TRUE (store->pending.get (transaction, key2, pending2)); } TEST (block_store, pending_iterator) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_write ()); - ASSERT_EQ (store->pending_end (), store->pending_begin (transaction)); - store->pending_put (transaction, nano::pending_key (1, 2), { 2, 3, nano::epoch::epoch_1 }); - auto current (store->pending_begin (transaction)); - ASSERT_NE (store->pending_end (), current); + ASSERT_EQ (store->pending.end (), store->pending.begin (transaction)); + store->pending.put (transaction, nano::pending_key (1, 2), { 2, 3, nano::epoch::epoch_1 }); + auto current (store->pending.begin (transaction)); + ASSERT_NE (store->pending.end (), current); nano::pending_key key1 (current->first); ASSERT_EQ (nano::account (1), key1.account); ASSERT_EQ (nano::block_hash (2), key1.hash); @@ -279,23 +279,23 @@ TEST (block_store, pending_iterator) TEST (block_store, pending_iterator_comparison) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; auto transaction (store->tx_begin_write ()); // Populate pending - store->pending_put (transaction, nano::pending_key (nano::account (3), nano::block_hash (1)), nano::pending_info (nano::account (10), nano::amount (1), nano::epoch::epoch_0)); - store->pending_put (transaction, nano::pending_key (nano::account (3), nano::block_hash (4)), nano::pending_info (nano::account (10), nano::amount (0), nano::epoch::epoch_0)); + store->pending.put (transaction, nano::pending_key (nano::account (3), nano::block_hash (1)), nano::pending_info (nano::account (10), nano::amount (1), nano::epoch::epoch_0)); + store->pending.put (transaction, nano::pending_key (nano::account (3), nano::block_hash (4)), nano::pending_info (nano::account (10), nano::amount (0), nano::epoch::epoch_0)); // Populate pending_v1 - store->pending_put (transaction, nano::pending_key (nano::account (2), nano::block_hash (2)), nano::pending_info (nano::account (10), nano::amount (2), nano::epoch::epoch_1)); - store->pending_put (transaction, nano::pending_key (nano::account (2), nano::block_hash (3)), nano::pending_info (nano::account (10), nano::amount (3), nano::epoch::epoch_1)); + store->pending.put (transaction, nano::pending_key (nano::account (2), nano::block_hash (2)), nano::pending_info (nano::account (10), nano::amount (2), nano::epoch::epoch_1)); + store->pending.put (transaction, nano::pending_key (nano::account (2), nano::block_hash (3)), nano::pending_info (nano::account (10), nano::amount (3), nano::epoch::epoch_1)); // Iterate account 3 (pending) { size_t count = 0; nano::account begin (3); nano::account end (begin.number () + 1); - for (auto i (store->pending_begin (transaction, nano::pending_key (begin, 0))), n (store->pending_begin (transaction, nano::pending_key (end, 0))); i != n; ++i, ++count) + for (auto i (store->pending.begin (transaction, nano::pending_key (begin, 0))), n (store->pending.begin (transaction, nano::pending_key (end, 0))); i != n; ++i, ++count) { nano::pending_key key (i->first); ASSERT_EQ (key.account, begin); @@ -309,7 +309,7 @@ TEST (block_store, pending_iterator_comparison) size_t count = 0; nano::account begin (2); nano::account end (begin.number () + 1); - for (auto i (store->pending_begin (transaction, nano::pending_key (begin, 0))), n (store->pending_begin (transaction, nano::pending_key (end, 0))); i != n; ++i, ++count) + for (auto i (store->pending.begin (transaction, nano::pending_key (begin, 0))), n (store->pending.begin (transaction, nano::pending_key (end, 0))); i != n; ++i, ++count) { nano::pending_key key (i->first); ASSERT_EQ (key.account, begin); @@ -322,17 +322,15 @@ TEST (block_store, pending_iterator_comparison) TEST (block_store, genesis) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); - nano::genesis genesis; - auto hash (genesis.hash ()); nano::ledger_cache ledger_cache; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger_cache); + store->initialize (transaction, ledger_cache); nano::account_info info; - ASSERT_FALSE (store->account_get (transaction, nano::genesis_account, info)); - ASSERT_EQ (hash, info.head); - auto block1 (store->block_get (transaction, info.head)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis->account (), info)); + ASSERT_EQ (nano::dev::genesis->hash (), info.head); + auto block1 (store->block.get (transaction, info.head)); ASSERT_NE (nullptr, block1); auto receive1 (dynamic_cast (block1.get ())); ASSERT_NE (nullptr, receive1); @@ -340,94 +338,94 @@ TEST (block_store, genesis) ASSERT_EQ (info.block_count, 1); // Genesis block should be confirmed by default nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store->confirmation_height_get (transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (store->confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 1); - ASSERT_EQ (confirmation_height_info.frontier, hash); - auto dev_pub_text (nano::dev_genesis_key.pub.to_string ()); - auto dev_pub_account (nano::dev_genesis_key.pub.to_account ()); - auto dev_prv_text (nano::dev_genesis_key.prv.to_string ()); - ASSERT_EQ (nano::genesis_account, nano::dev_genesis_key.pub); + ASSERT_EQ (confirmation_height_info.frontier, nano::dev::genesis->hash ()); + auto dev_pub_text (nano::dev::genesis_key.pub.to_string ()); + auto dev_pub_account (nano::dev::genesis_key.pub.to_account ()); + auto dev_prv_text (nano::dev::genesis_key.prv.to_string ()); + ASSERT_EQ (nano::dev::genesis->account (), nano::dev::genesis_key.pub); } TEST (bootstrap, simple) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto block1 (std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5)); auto transaction (store->tx_begin_write ()); - auto block2 (store->unchecked_get (transaction, block1->previous ())); + auto block2 (store->unchecked.get (transaction, block1->previous ())); ASSERT_TRUE (block2.empty ()); - store->unchecked_put (transaction, block1->previous (), block1); - auto block3 (store->unchecked_get (transaction, block1->previous ())); + store->unchecked.put (transaction, block1->previous (), block1); + auto block3 (store->unchecked.get (transaction, block1->previous ())); ASSERT_FALSE (block3.empty ()); ASSERT_EQ (*block1, *(block3[0].block)); - store->unchecked_del (transaction, nano::unchecked_key (block1->previous (), block1->hash ())); - auto block4 (store->unchecked_get (transaction, block1->previous ())); + store->unchecked.del (transaction, nano::unchecked_key (block1->previous (), block1->hash ())); + auto block4 (store->unchecked.get (transaction, block1->previous ())); ASSERT_TRUE (block4.empty ()); } TEST (unchecked, multiple) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; } nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto block1 (std::make_shared (4, 1, 2, nano::keypair ().prv, 4, 5)); auto transaction (store->tx_begin_write ()); - auto block2 (store->unchecked_get (transaction, block1->previous ())); + auto block2 (store->unchecked.get (transaction, block1->previous ())); ASSERT_TRUE (block2.empty ()); - store->unchecked_put (transaction, block1->previous (), block1); - store->unchecked_put (transaction, block1->source (), block1); - auto block3 (store->unchecked_get (transaction, block1->previous ())); + store->unchecked.put (transaction, block1->previous (), block1); + store->unchecked.put (transaction, block1->source (), block1); + auto block3 (store->unchecked.get (transaction, block1->previous ())); ASSERT_FALSE (block3.empty ()); - auto block4 (store->unchecked_get (transaction, block1->source ())); + auto block4 (store->unchecked.get (transaction, block1->source ())); ASSERT_FALSE (block4.empty ()); } TEST (unchecked, double_put) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto block1 (std::make_shared (4, 1, 2, nano::keypair ().prv, 4, 5)); auto transaction (store->tx_begin_write ()); - auto block2 (store->unchecked_get (transaction, block1->previous ())); + auto block2 (store->unchecked.get (transaction, block1->previous ())); ASSERT_TRUE (block2.empty ()); - store->unchecked_put (transaction, block1->previous (), block1); - store->unchecked_put (transaction, block1->previous (), block1); - auto block3 (store->unchecked_get (transaction, block1->previous ())); + store->unchecked.put (transaction, block1->previous (), block1); + store->unchecked.put (transaction, block1->previous (), block1); + auto block3 (store->unchecked.get (transaction, block1->previous ())); ASSERT_EQ (block3.size (), 1); } TEST (unchecked, multiple_get) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto block1 (std::make_shared (4, 1, 2, nano::keypair ().prv, 4, 5)); auto block2 (std::make_shared (3, 1, 2, nano::keypair ().prv, 4, 5)); auto block3 (std::make_shared (5, 1, 2, nano::keypair ().prv, 4, 5)); { auto transaction (store->tx_begin_write ()); - store->unchecked_put (transaction, block1->previous (), block1); // unchecked1 - store->unchecked_put (transaction, block1->hash (), block1); // unchecked2 - store->unchecked_put (transaction, block2->previous (), block2); // unchecked3 - store->unchecked_put (transaction, block1->previous (), block2); // unchecked1 - store->unchecked_put (transaction, block1->hash (), block2); // unchecked2 - store->unchecked_put (transaction, block3->previous (), block3); - store->unchecked_put (transaction, block3->hash (), block3); // unchecked4 - store->unchecked_put (transaction, block1->previous (), block3); // unchecked1 + store->unchecked.put (transaction, block1->previous (), block1); // unchecked1 + store->unchecked.put (transaction, block1->hash (), block1); // unchecked2 + store->unchecked.put (transaction, block2->previous (), block2); // unchecked3 + store->unchecked.put (transaction, block1->previous (), block2); // unchecked1 + store->unchecked.put (transaction, block1->hash (), block2); // unchecked2 + store->unchecked.put (transaction, block3->previous (), block3); + store->unchecked.put (transaction, block3->hash (), block3); // unchecked4 + store->unchecked.put (transaction, block1->previous (), block3); // unchecked1 } auto transaction (store->tx_begin_read ()); - auto unchecked_count (store->unchecked_count (transaction)); + auto unchecked_count (store->unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 8); std::vector unchecked1; - auto unchecked1_blocks (store->unchecked_get (transaction, block1->previous ())); + auto unchecked1_blocks (store->unchecked.get (transaction, block1->previous ())); ASSERT_EQ (unchecked1_blocks.size (), 3); for (auto & i : unchecked1_blocks) { @@ -437,7 +435,7 @@ TEST (unchecked, multiple_get) ASSERT_TRUE (std::find (unchecked1.begin (), unchecked1.end (), block2->hash ()) != unchecked1.end ()); ASSERT_TRUE (std::find (unchecked1.begin (), unchecked1.end (), block3->hash ()) != unchecked1.end ()); std::vector unchecked2; - auto unchecked2_blocks (store->unchecked_get (transaction, block1->hash ())); + auto unchecked2_blocks (store->unchecked.get (transaction, block1->hash ())); ASSERT_EQ (unchecked2_blocks.size (), 2); for (auto & i : unchecked2_blocks) { @@ -445,64 +443,64 @@ TEST (unchecked, multiple_get) } ASSERT_TRUE (std::find (unchecked2.begin (), unchecked2.end (), block1->hash ()) != unchecked2.end ()); ASSERT_TRUE (std::find (unchecked2.begin (), unchecked2.end (), block2->hash ()) != unchecked2.end ()); - auto unchecked3 (store->unchecked_get (transaction, block2->previous ())); + auto unchecked3 (store->unchecked.get (transaction, block2->previous ())); ASSERT_EQ (unchecked3.size (), 1); ASSERT_EQ (unchecked3[0].block->hash (), block2->hash ()); - auto unchecked4 (store->unchecked_get (transaction, block3->hash ())); + auto unchecked4 (store->unchecked.get (transaction, block3->hash ())); ASSERT_EQ (unchecked4.size (), 1); ASSERT_EQ (unchecked4[0].block->hash (), block3->hash ()); - auto unchecked5 (store->unchecked_get (transaction, block2->hash ())); + auto unchecked5 (store->unchecked.get (transaction, block2->hash ())); ASSERT_EQ (unchecked5.size (), 0); } TEST (block_store, empty_accounts) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_read ()); - auto begin (store->accounts_begin (transaction)); - auto end (store->accounts_end ()); + auto begin (store->account.begin (transaction)); + auto end (store->account.end ()); ASSERT_EQ (end, begin); } TEST (block_store, one_block) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::open_block block1 (0, 1, 0, nano::keypair ().prv, 0, 0); block1.sideband_set ({}); auto transaction (store->tx_begin_write ()); - store->block_put (transaction, block1.hash (), block1); - ASSERT_TRUE (store->block_exists (transaction, block1.hash ())); + store->block.put (transaction, block1.hash (), block1); + ASSERT_TRUE (store->block.exists (transaction, block1.hash ())); } TEST (block_store, empty_bootstrap) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_read ()); - auto begin (store->unchecked_begin (transaction)); - auto end (store->unchecked_end ()); + auto begin (store->unchecked.begin (transaction)); + auto end (store->unchecked.end ()); ASSERT_EQ (end, begin); } TEST (block_store, one_bootstrap) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto block1 (std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5)); auto transaction (store->tx_begin_write ()); - store->unchecked_put (transaction, block1->hash (), block1); - auto begin (store->unchecked_begin (transaction)); - auto end (store->unchecked_end ()); + store->unchecked.put (transaction, block1->hash (), block1); + auto begin (store->unchecked.begin (transaction)); + auto end (store->unchecked.end ()); ASSERT_NE (end, begin); auto hash1 (begin->first.key ()); ASSERT_EQ (block1->hash (), hash1); - auto blocks (store->unchecked_get (transaction, hash1)); + auto blocks (store->unchecked.get (transaction, hash1)); ASSERT_EQ (1, blocks.size ()); auto block2 (blocks[0].block); ASSERT_EQ (*block1, *block2); @@ -513,7 +511,7 @@ TEST (block_store, one_bootstrap) TEST (block_store, unchecked_begin_search) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key0; nano::send_block block1 (0, 1, 2, key0.prv, key0.pub, 3); @@ -523,30 +521,30 @@ TEST (block_store, unchecked_begin_search) TEST (block_store, frontier_retrieval) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); - nano::account account1 (0); + nano::account account1{}; nano::account_info info1 (0, 0, 0, 0, 0, 0, nano::epoch::epoch_0); auto transaction (store->tx_begin_write ()); - store->confirmation_height_put (transaction, account1, { 0, nano::block_hash (0) }); - store->account_put (transaction, account1, info1); + store->confirmation_height.put (transaction, account1, { 0, nano::block_hash (0) }); + store->account.put (transaction, account1, info1); nano::account_info info2; - store->account_get (transaction, account1, info2); + store->account.get (transaction, account1, info2); ASSERT_EQ (info1, info2); } TEST (block_store, one_account) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); - nano::account account (0); + nano::account account{}; nano::block_hash hash (0); auto transaction (store->tx_begin_write ()); - store->confirmation_height_put (transaction, account, { 20, nano::block_hash (15) }); - store->account_put (transaction, account, { hash, account, hash, 42, 100, 200, nano::epoch::epoch_0 }); - auto begin (store->accounts_begin (transaction)); - auto end (store->accounts_end ()); + store->confirmation_height.put (transaction, account, { 20, nano::block_hash (15) }); + store->account.put (transaction, account, { hash, account, hash, 42, 100, 200, nano::epoch::epoch_0 }); + auto begin (store->account.begin (transaction)); + auto end (store->account.end ()); ASSERT_NE (end, begin); ASSERT_EQ (account, nano::account (begin->first)); nano::account_info info (begin->second); @@ -555,7 +553,7 @@ TEST (block_store, one_account) ASSERT_EQ (100, info.modified); ASSERT_EQ (200, info.block_count); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store->confirmation_height_get (transaction, account, confirmation_height_info)); + ASSERT_FALSE (store->confirmation_height.get (transaction, account, confirmation_height_info)); ASSERT_EQ (20, confirmation_height_info.height); ASSERT_EQ (nano::block_hash (15), confirmation_height_info.frontier); ++begin; @@ -565,7 +563,7 @@ TEST (block_store, one_account) TEST (block_store, two_block) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::open_block block1 (0, 1, 1, nano::keypair ().prv, 0, 0); block1.sideband_set ({}); @@ -575,32 +573,32 @@ TEST (block_store, two_block) hashes.push_back (block1.hash ()); blocks.push_back (block1); auto transaction (store->tx_begin_write ()); - store->block_put (transaction, hashes[0], block1); + store->block.put (transaction, hashes[0], block1); nano::open_block block2 (0, 1, 2, nano::keypair ().prv, 0, 0); block2.sideband_set ({}); hashes.push_back (block2.hash ()); blocks.push_back (block2); - store->block_put (transaction, hashes[1], block2); - ASSERT_TRUE (store->block_exists (transaction, block1.hash ())); - ASSERT_TRUE (store->block_exists (transaction, block2.hash ())); + store->block.put (transaction, hashes[1], block2); + ASSERT_TRUE (store->block.exists (transaction, block1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, block2.hash ())); } TEST (block_store, two_account) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::account account1 (1); nano::block_hash hash1 (2); nano::account account2 (3); nano::block_hash hash2 (4); auto transaction (store->tx_begin_write ()); - store->confirmation_height_put (transaction, account1, { 20, nano::block_hash (10) }); - store->account_put (transaction, account1, { hash1, account1, hash1, 42, 100, 300, nano::epoch::epoch_0 }); - store->confirmation_height_put (transaction, account2, { 30, nano::block_hash (20) }); - store->account_put (transaction, account2, { hash2, account2, hash2, 84, 200, 400, nano::epoch::epoch_0 }); - auto begin (store->accounts_begin (transaction)); - auto end (store->accounts_end ()); + store->confirmation_height.put (transaction, account1, { 20, nano::block_hash (10) }); + store->account.put (transaction, account1, { hash1, account1, hash1, 42, 100, 300, nano::epoch::epoch_0 }); + store->confirmation_height.put (transaction, account2, { 30, nano::block_hash (20) }); + store->account.put (transaction, account2, { hash2, account2, hash2, 84, 200, 400, nano::epoch::epoch_0 }); + auto begin (store->account.begin (transaction)); + auto end (store->account.end ()); ASSERT_NE (end, begin); ASSERT_EQ (account1, nano::account (begin->first)); nano::account_info info1 (begin->second); @@ -609,7 +607,7 @@ TEST (block_store, two_account) ASSERT_EQ (100, info1.modified); ASSERT_EQ (300, info1.block_count); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store->confirmation_height_get (transaction, account1, confirmation_height_info)); + ASSERT_FALSE (store->confirmation_height.get (transaction, account1, confirmation_height_info)); ASSERT_EQ (20, confirmation_height_info.height); ASSERT_EQ (nano::block_hash (10), confirmation_height_info.frontier); ++begin; @@ -620,7 +618,7 @@ TEST (block_store, two_account) ASSERT_EQ (84, info2.balance.number ()); ASSERT_EQ (200, info2.modified); ASSERT_EQ (400, info2.block_count); - ASSERT_FALSE (store->confirmation_height_get (transaction, account2, confirmation_height_info)); + ASSERT_FALSE (store->confirmation_height.get (transaction, account2, confirmation_height_info)); ASSERT_EQ (30, confirmation_height_info.height); ASSERT_EQ (nano::block_hash (20), confirmation_height_info.frontier); ++begin; @@ -630,88 +628,87 @@ TEST (block_store, two_account) TEST (block_store, latest_find) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::account account1 (1); nano::block_hash hash1 (2); nano::account account2 (3); nano::block_hash hash2 (4); auto transaction (store->tx_begin_write ()); - store->confirmation_height_put (transaction, account1, { 0, nano::block_hash (0) }); - store->account_put (transaction, account1, { hash1, account1, hash1, 100, 0, 300, nano::epoch::epoch_0 }); - store->confirmation_height_put (transaction, account2, { 0, nano::block_hash (0) }); - store->account_put (transaction, account2, { hash2, account2, hash2, 200, 0, 400, nano::epoch::epoch_0 }); - auto first (store->accounts_begin (transaction)); - auto second (store->accounts_begin (transaction)); + store->confirmation_height.put (transaction, account1, { 0, nano::block_hash (0) }); + store->account.put (transaction, account1, { hash1, account1, hash1, 100, 0, 300, nano::epoch::epoch_0 }); + store->confirmation_height.put (transaction, account2, { 0, nano::block_hash (0) }); + store->account.put (transaction, account2, { hash2, account2, hash2, 200, 0, 400, nano::epoch::epoch_0 }); + auto first (store->account.begin (transaction)); + auto second (store->account.begin (transaction)); ++second; - auto find1 (store->accounts_begin (transaction, 1)); + auto find1 (store->account.begin (transaction, 1)); ASSERT_EQ (first, find1); - auto find2 (store->accounts_begin (transaction, 3)); + auto find2 (store->account.begin (transaction, 3)); ASSERT_EQ (second, find2); - auto find3 (store->accounts_begin (transaction, 2)); + auto find3 (store->account.begin (transaction, 2)); ASSERT_EQ (second, find3); } TEST (mdb_block_store, supported_version_upgrades) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; } // Check that upgrading from an unsupported version is not supported auto path (nano::unique_path ()); - nano::genesis genesis; nano::logger_mt logger; { - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); nano::stat stats; - nano::ledger ledger (store, stats); + nano::ledger ledger (store, stats, nano::dev::constants); auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis, ledger.cache); + store.initialize (transaction, ledger.cache); // Lower the database to the max version unsupported for upgrades - store.version_put (transaction, store.minimum_version - 1); + store.version.put (transaction, store.minimum_version - 1); } // Upgrade should fail { - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); ASSERT_TRUE (store.init_error ()); } auto path1 (nano::unique_path ()); // Now try with the minimum version { - nano::mdb_store store (logger, path1); + nano::mdb_store store (logger, path1, nano::dev::constants); nano::stat stats; - nano::ledger ledger (store, stats); + nano::ledger ledger (store, stats, nano::dev::constants); auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis, ledger.cache); + store.initialize (transaction, ledger.cache); // Lower the database version to the minimum version supported for upgrade. - store.version_put (transaction, store.minimum_version); - store.confirmation_height_del (transaction, nano::genesis_account); - ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "accounts_v1", MDB_CREATE, &store.accounts_v1)); - ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks)); - modify_account_info_to_v14 (store, transaction, nano::genesis_account, 1, nano::genesis_hash); - write_block_w_sideband_v18 (store, store.open_blocks, transaction, *nano::genesis ().open); + store.version.put (transaction, store.minimum_version); + store.confirmation_height.del (transaction, nano::dev::genesis->account ()); + ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "accounts_v1", MDB_CREATE, &store.accounts_v1_handle)); + ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle)); + modify_account_info_to_v14 (store, transaction, nano::dev::genesis->account (), 1, nano::dev::genesis->hash ()); + write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis); } // Upgrade should work { - nano::mdb_store store (logger, path1); + nano::mdb_store store (logger, path1, nano::dev::constants); ASSERT_FALSE (store.init_error ()); } } TEST (mdb_block_store, bad_path) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; } nano::logger_mt logger; - nano::mdb_store store (logger, boost::filesystem::path ("///")); + nano::mdb_store store (logger, boost::filesystem::path ("///"), nano::dev::constants); ASSERT_TRUE (store.init_error ()); } @@ -724,14 +721,14 @@ TEST (block_store, DISABLED_already_open) // File can be shared file.open (path.string ().c_str ()); ASSERT_TRUE (file.is_open ()); nano::logger_mt logger; - auto store = nano::make_store (logger, path); + auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (store->init_error ()); } TEST (block_store, roots) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::send_block send_block (0, 1, 2, nano::keypair ().prv, 4, 5); ASSERT_EQ (send_block.hashables.previous, send_block.root ()); @@ -746,34 +743,34 @@ TEST (block_store, roots) TEST (block_store, pending_exists) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::pending_key two (2, 0); nano::pending_info pending; auto transaction (store->tx_begin_write ()); - store->pending_put (transaction, two, pending); + store->pending.put (transaction, two, pending); nano::pending_key one (1, 0); - ASSERT_FALSE (store->pending_exists (transaction, one)); + ASSERT_FALSE (store->pending.exists (transaction, one)); } TEST (block_store, latest_exists) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::account two (2); nano::account_info info; auto transaction (store->tx_begin_write ()); - store->confirmation_height_put (transaction, two, { 0, nano::block_hash (0) }); - store->account_put (transaction, two, info); + store->confirmation_height.put (transaction, two, { 0, nano::block_hash (0) }); + store->account.put (transaction, two, info); nano::account one (1); - ASSERT_FALSE (store->account_exists (transaction, one)); + ASSERT_FALSE (store->account.exists (transaction, one)); } TEST (block_store, large_iteration) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); std::unordered_set accounts1; for (auto i (0); i < 1000; ++i) @@ -782,13 +779,13 @@ TEST (block_store, large_iteration) nano::account account; nano::random_pool::generate_block (account.bytes.data (), account.bytes.size ()); accounts1.insert (account); - store->confirmation_height_put (transaction, account, { 0, nano::block_hash (0) }); - store->account_put (transaction, account, nano::account_info ()); + store->confirmation_height.put (transaction, account, { 0, nano::block_hash (0) }); + store->account.put (transaction, account, nano::account_info ()); } std::unordered_set accounts2; - nano::account previous (0); + nano::account previous{}; auto transaction (store->tx_begin_read ()); - for (auto i (store->accounts_begin (transaction, 0)), n (store->accounts_end ()); i != n; ++i) + for (auto i (store->account.begin (transaction, 0)), n (store->account.end ()); i != n; ++i) { nano::account current (i->first); ASSERT_GT (current.number (), previous.number ()); @@ -799,7 +796,7 @@ TEST (block_store, large_iteration) // Reverse iteration std::unordered_set accounts3; previous = std::numeric_limits::max (); - for (auto i (store->accounts_rbegin (transaction)), n (store->accounts_end ()); i != n; --i) + for (auto i (store->account.rbegin (transaction)), n (store->account.end ()); i != n; --i) { nano::account current (i->first); ASSERT_LT (current.number (), previous.number ()); @@ -812,31 +809,31 @@ TEST (block_store, large_iteration) TEST (block_store, frontier) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_write ()); nano::block_hash hash (100); nano::account account (200); - ASSERT_TRUE (store->frontier_get (transaction, hash).is_zero ()); - store->frontier_put (transaction, hash, account); - ASSERT_EQ (account, store->frontier_get (transaction, hash)); - store->frontier_del (transaction, hash); - ASSERT_TRUE (store->frontier_get (transaction, hash).is_zero ()); + ASSERT_TRUE (store->frontier.get (transaction, hash).is_zero ()); + store->frontier.put (transaction, hash, account); + ASSERT_EQ (account, store->frontier.get (transaction, hash)); + store->frontier.del (transaction, hash); + ASSERT_TRUE (store->frontier.get (transaction, hash).is_zero ()); } TEST (block_store, block_replace) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::send_block send1 (0, 0, 0, nano::keypair ().prv, 0, 1); send1.sideband_set ({}); nano::send_block send2 (0, 0, 0, nano::keypair ().prv, 0, 2); send2.sideband_set ({}); auto transaction (store->tx_begin_write ()); - store->block_put (transaction, 0, send1); - store->block_put (transaction, 0, send2); - auto block3 (store->block_get (transaction, 0)); + store->block.put (transaction, 0, send1); + store->block.put (transaction, 0, send2); + auto block3 (store->block.get (transaction, 0)); ASSERT_NE (nullptr, block3); ASSERT_EQ (2, block3->block_work ()); } @@ -844,82 +841,78 @@ TEST (block_store, block_replace) TEST (block_store, block_count) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); { auto transaction (store->tx_begin_write ()); - ASSERT_EQ (0, store->block_count (transaction)); + ASSERT_EQ (0, store->block.count (transaction)); nano::open_block block (0, 1, 0, nano::keypair ().prv, 0, 0); block.sideband_set ({}); auto hash1 (block.hash ()); - store->block_put (transaction, hash1, block); + store->block.put (transaction, hash1, block); } auto transaction (store->tx_begin_read ()); - ASSERT_EQ (1, store->block_count (transaction)); + ASSERT_EQ (1, store->block.count (transaction)); } TEST (block_store, account_count) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); { auto transaction (store->tx_begin_write ()); - ASSERT_EQ (0, store->account_count (transaction)); + ASSERT_EQ (0, store->account.count (transaction)); nano::account account (200); - store->confirmation_height_put (transaction, account, { 0, nano::block_hash (0) }); - store->account_put (transaction, account, nano::account_info ()); + store->confirmation_height.put (transaction, account, { 0, nano::block_hash (0) }); + store->account.put (transaction, account, nano::account_info ()); } auto transaction (store->tx_begin_read ()); - ASSERT_EQ (1, store->account_count (transaction)); + ASSERT_EQ (1, store->account.count (transaction)); } TEST (block_store, cemented_count_cache) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto transaction (store->tx_begin_write ()); - nano::genesis genesis; nano::ledger_cache ledger_cache; - store->initialize (transaction, genesis, ledger_cache); + store->initialize (transaction, ledger_cache); ASSERT_EQ (1, ledger_cache.cemented_count); } TEST (block_store, block_random) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); - ASSERT_TRUE (!store->init_error ()); - nano::genesis genesis; + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); { nano::ledger_cache ledger_cache; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger_cache); + store->initialize (transaction, ledger_cache); } auto transaction (store->tx_begin_read ()); - auto block (store->block_random (transaction)); + auto block (store->block.random (transaction)); ASSERT_NE (nullptr, block); - ASSERT_EQ (*block, *genesis.open); + ASSERT_EQ (*block, *nano::dev::genesis); } TEST (block_store, pruned_random) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); - nano::genesis genesis; nano::open_block block (0, 1, 0, nano::keypair ().prv, 0, 0); block.sideband_set ({}); auto hash1 (block.hash ()); { nano::ledger_cache ledger_cache; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger_cache); - store->pruned_put (transaction, hash1); + store->initialize (transaction, ledger_cache); + store->pruned.put (transaction, hash1); } auto transaction (store->tx_begin_read ()); - auto random_hash (store->pruned_random (transaction)); + auto random_hash (store->pruned.random (transaction)); ASSERT_EQ (hash1, random_hash); } @@ -928,148 +921,146 @@ TEST (block_store, DISABLED_change_dupsort) // Unchecked is no longer dupsort ta { auto path (nano::unique_path ()); nano::logger_mt logger; - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); auto transaction (store.tx_begin_write ()); - ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked, 1)); - ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE, &store.unchecked)); - auto send1 (std::make_shared (0, 0, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); - auto send2 (std::make_shared (1, 0, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked_handle, 1)); + ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE, &store.unchecked_handle)); + auto send1 (std::make_shared (0, 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); + auto send2 (std::make_shared (1, 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); ASSERT_NE (send1->hash (), send2->hash ()); - store.unchecked_put (transaction, send1->hash (), send1); - store.unchecked_put (transaction, send1->hash (), send2); + store.unchecked.put (transaction, send1->hash (), send1); + store.unchecked.put (transaction, send1->hash (), send2); { - auto iterator1 (store.unchecked_begin (transaction)); + auto iterator1 (store.unchecked.begin (transaction)); ++iterator1; - ASSERT_EQ (store.unchecked_end (), iterator1); + ASSERT_EQ (store.unchecked.end (), iterator1); } - ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked, 0)); - mdb_dbi_close (store.env, store.unchecked); - ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE | MDB_DUPSORT, &store.unchecked)); - store.unchecked_put (transaction, send1->hash (), send1); - store.unchecked_put (transaction, send1->hash (), send2); + ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked_handle, 0)); + mdb_dbi_close (store.env, store.unchecked_handle); + ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE | MDB_DUPSORT, &store.unchecked_handle)); + store.unchecked.put (transaction, send1->hash (), send1); + store.unchecked.put (transaction, send1->hash (), send2); { - auto iterator1 (store.unchecked_begin (transaction)); + auto iterator1 (store.unchecked.begin (transaction)); ++iterator1; - ASSERT_EQ (store.unchecked_end (), iterator1); + ASSERT_EQ (store.unchecked.end (), iterator1); } - ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked, 1)); - ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE | MDB_DUPSORT, &store.unchecked)); - store.unchecked_put (transaction, send1->hash (), send1); - store.unchecked_put (transaction, send1->hash (), send2); + ASSERT_EQ (0, mdb_drop (store.env.tx (transaction), store.unchecked_handle, 1)); + ASSERT_EQ (0, mdb_dbi_open (store.env.tx (transaction), "unchecked", MDB_CREATE | MDB_DUPSORT, &store.unchecked_handle)); + store.unchecked.put (transaction, send1->hash (), send1); + store.unchecked.put (transaction, send1->hash (), send2); { - auto iterator1 (store.unchecked_begin (transaction)); + auto iterator1 (store.unchecked.begin (transaction)); ++iterator1; - ASSERT_NE (store.unchecked_end (), iterator1); + ASSERT_NE (store.unchecked.end (), iterator1); ++iterator1; - ASSERT_EQ (store.unchecked_end (), iterator1); + ASSERT_EQ (store.unchecked.end (), iterator1); } } TEST (block_store, state_block) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); - nano::genesis genesis; nano::keypair key1; - nano::state_block block1 (1, genesis.hash (), 3, 4, 6, key1.prv, key1.pub, 7); + nano::state_block block1 (1, nano::dev::genesis->hash (), 3, 4, 6, key1.prv, key1.pub, 7); block1.sideband_set ({}); { nano::ledger_cache ledger_cache; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger_cache); + store->initialize (transaction, ledger_cache); ASSERT_EQ (nano::block_type::state, block1.type ()); - store->block_put (transaction, block1.hash (), block1); - ASSERT_TRUE (store->block_exists (transaction, block1.hash ())); - auto block2 (store->block_get (transaction, block1.hash ())); + store->block.put (transaction, block1.hash (), block1); + ASSERT_TRUE (store->block.exists (transaction, block1.hash ())); + auto block2 (store->block.get (transaction, block1.hash ())); ASSERT_NE (nullptr, block2); ASSERT_EQ (block1, *block2); } { auto transaction (store->tx_begin_write ()); - auto count (store->block_count (transaction)); + auto count (store->block.count (transaction)); ASSERT_EQ (2, count); - store->block_del (transaction, block1.hash ()); - ASSERT_FALSE (store->block_exists (transaction, block1.hash ())); + store->block.del (transaction, block1.hash ()); + ASSERT_FALSE (store->block.exists (transaction, block1.hash ())); } auto transaction (store->tx_begin_read ()); - auto count2 (store->block_count (transaction)); + auto count2 (store->block.count (transaction)); ASSERT_EQ (1, count2); } TEST (mdb_block_store, sideband_height) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; } nano::logger_mt logger; - nano::genesis genesis; nano::keypair key1; nano::keypair key2; nano::keypair key3; - nano::mdb_store store (logger, nano::unique_path ()); + nano::mdb_store store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store.init_error ()); nano::stat stat; - nano::ledger ledger (store, stat); + nano::ledger ledger (store, stat, nano::dev::constants); auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::send_block send (genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store.initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::send_block send (nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); - nano::receive_block receive (send.hash (), send.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send.hash ())); + nano::receive_block receive (send.hash (), send.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code); - nano::change_block change (receive.hash (), 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (receive.hash ())); + nano::change_block change (receive.hash (), 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (receive.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change).code); - nano::state_block state_send1 (nano::dev_genesis_key.pub, change.hash (), 0, nano::genesis_amount - nano::MBAN_ratio, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (change.hash ())); + nano::state_block state_send1 (nano::dev::genesis_key.pub, change.hash (), 0, nano::dev::constants.genesis_amount - nano::MBAN_ratio, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (change.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send1).code); - nano::state_block state_send2 (nano::dev_genesis_key.pub, state_send1.hash (), 0, nano::genesis_amount - 2 * nano::MBAN_ratio, key2.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (state_send1.hash ())); + nano::state_block state_send2 (nano::dev::genesis_key.pub, state_send1.hash (), 0, nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send2).code); - nano::state_block state_send3 (nano::dev_genesis_key.pub, state_send2.hash (), 0, nano::genesis_amount - 3 * nano::MBAN_ratio, key3.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (state_send2.hash ())); + nano::state_block state_send3 (nano::dev::genesis_key.pub, state_send2.hash (), 0, nano::dev::constants.genesis_amount - 3 * nano::MBAN_ratio, key3.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_send2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send3).code); nano::state_block state_open (key1.pub, 0, 0, nano::MBAN_ratio, state_send1.hash (), key1.prv, key1.pub, *pool.generate (key1.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_open).code); - nano::state_block epoch (key1.pub, state_open.hash (), 0, nano::MBAN_ratio, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (state_open.hash ())); + nano::state_block epoch (key1.pub, state_open.hash (), 0, nano::MBAN_ratio, ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_open.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch).code); - ASSERT_EQ (nano::epoch::epoch_1, store.block_version (transaction, epoch.hash ())); - nano::state_block epoch_open (key2.pub, 0, 0, 0, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (key2.pub)); + ASSERT_EQ (nano::epoch::epoch_1, store.block.version (transaction, epoch.hash ())); + nano::state_block epoch_open (key2.pub, 0, 0, 0, ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (key2.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch_open).code); - ASSERT_EQ (nano::epoch::epoch_1, store.block_version (transaction, epoch_open.hash ())); + ASSERT_EQ (nano::epoch::epoch_1, store.block.version (transaction, epoch_open.hash ())); nano::state_block state_receive (key2.pub, epoch_open.hash (), 0, nano::MBAN_ratio, state_send2.hash (), key2.prv, key2.pub, *pool.generate (epoch_open.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_receive).code); - nano::open_block open (state_send3.hash (), nano::dev_genesis_key.pub, key3.pub, key3.prv, key3.pub, *pool.generate (key3.pub)); + nano::open_block open (state_send3.hash (), nano::dev::genesis_key.pub, key3.pub, key3.prv, key3.pub, *pool.generate (key3.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); - auto block1 (store.block_get (transaction, genesis.hash ())); + auto block1 (store.block.get (transaction, nano::dev::genesis->hash ())); ASSERT_EQ (block1->sideband ().height, 1); - auto block2 (store.block_get (transaction, send.hash ())); + auto block2 (store.block.get (transaction, send.hash ())); ASSERT_EQ (block2->sideband ().height, 2); - auto block3 (store.block_get (transaction, receive.hash ())); + auto block3 (store.block.get (transaction, receive.hash ())); ASSERT_EQ (block3->sideband ().height, 3); - auto block4 (store.block_get (transaction, change.hash ())); + auto block4 (store.block.get (transaction, change.hash ())); ASSERT_EQ (block4->sideband ().height, 4); - auto block5 (store.block_get (transaction, state_send1.hash ())); + auto block5 (store.block.get (transaction, state_send1.hash ())); ASSERT_EQ (block5->sideband ().height, 5); - auto block6 (store.block_get (transaction, state_send2.hash ())); + auto block6 (store.block.get (transaction, state_send2.hash ())); ASSERT_EQ (block6->sideband ().height, 6); - auto block7 (store.block_get (transaction, state_send3.hash ())); + auto block7 (store.block.get (transaction, state_send3.hash ())); ASSERT_EQ (block7->sideband ().height, 7); - auto block8 (store.block_get (transaction, state_open.hash ())); + auto block8 (store.block.get (transaction, state_open.hash ())); ASSERT_EQ (block8->sideband ().height, 1); - auto block9 (store.block_get (transaction, epoch.hash ())); + auto block9 (store.block.get (transaction, epoch.hash ())); ASSERT_EQ (block9->sideband ().height, 2); - auto block10 (store.block_get (transaction, epoch_open.hash ())); + auto block10 (store.block.get (transaction, epoch_open.hash ())); ASSERT_EQ (block10->sideband ().height, 1); - auto block11 (store.block_get (transaction, state_receive.hash ())); + auto block11 (store.block.get (transaction, state_receive.hash ())); ASSERT_EQ (block11->sideband ().height, 2); - auto block12 (store.block_get (transaction, open.hash ())); + auto block12 (store.block.get (transaction, open.hash ())); ASSERT_EQ (block12->sideband ().height, 1); } TEST (block_store, peers) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::endpoint_key endpoint (boost::asio::ip::address_v6::any ().to_bytes (), 100); @@ -1077,57 +1068,57 @@ TEST (block_store, peers) auto transaction (store->tx_begin_write ()); // Confirm that the store is empty - ASSERT_FALSE (store->peer_exists (transaction, endpoint)); - ASSERT_EQ (store->peer_count (transaction), 0); + ASSERT_FALSE (store->peer.exists (transaction, endpoint)); + ASSERT_EQ (store->peer.count (transaction), 0); // Add one - store->peer_put (transaction, endpoint); - ASSERT_TRUE (store->peer_exists (transaction, endpoint)); + store->peer.put (transaction, endpoint); + ASSERT_TRUE (store->peer.exists (transaction, endpoint)); } // Confirm that it can be found { auto transaction (store->tx_begin_read ()); - ASSERT_EQ (store->peer_count (transaction), 1); + ASSERT_EQ (store->peer.count (transaction), 1); } // Add another one and check that it (and the existing one) can be found nano::endpoint_key endpoint1 (boost::asio::ip::address_v6::any ().to_bytes (), 101); { auto transaction (store->tx_begin_write ()); - store->peer_put (transaction, endpoint1); - ASSERT_TRUE (store->peer_exists (transaction, endpoint1)); // Check new peer is here - ASSERT_TRUE (store->peer_exists (transaction, endpoint)); // Check first peer is still here + store->peer.put (transaction, endpoint1); + ASSERT_TRUE (store->peer.exists (transaction, endpoint1)); // Check new peer is here + ASSERT_TRUE (store->peer.exists (transaction, endpoint)); // Check first peer is still here } { auto transaction (store->tx_begin_read ()); - ASSERT_EQ (store->peer_count (transaction), 2); + ASSERT_EQ (store->peer.count (transaction), 2); } // Delete the first one { auto transaction (store->tx_begin_write ()); - store->peer_del (transaction, endpoint1); - ASSERT_FALSE (store->peer_exists (transaction, endpoint1)); // Confirm it no longer exists - ASSERT_TRUE (store->peer_exists (transaction, endpoint)); // Check first peer is still here + store->peer.del (transaction, endpoint1); + ASSERT_FALSE (store->peer.exists (transaction, endpoint1)); // Confirm it no longer exists + ASSERT_TRUE (store->peer.exists (transaction, endpoint)); // Check first peer is still here } { auto transaction (store->tx_begin_read ()); - ASSERT_EQ (store->peer_count (transaction), 1); + ASSERT_EQ (store->peer.count (transaction), 1); } // Delete original one { auto transaction (store->tx_begin_write ()); - store->peer_del (transaction, endpoint); - ASSERT_FALSE (store->peer_exists (transaction, endpoint)); + store->peer.del (transaction, endpoint); + ASSERT_FALSE (store->peer.exists (transaction, endpoint)); } { auto transaction (store->tx_begin_read ()); - ASSERT_EQ (store->peer_count (transaction), 0); + ASSERT_EQ (store->peer.count (transaction), 0); } } @@ -1167,42 +1158,42 @@ TEST (block_store, endpoint_key_byte_order) TEST (block_store, online_weight) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); { auto transaction (store->tx_begin_write ()); - ASSERT_EQ (0, store->online_weight_count (transaction)); - ASSERT_EQ (store->online_weight_end (), store->online_weight_begin (transaction)); - ASSERT_EQ (store->online_weight_end (), store->online_weight_rbegin (transaction)); - store->online_weight_put (transaction, 1, 2); - store->online_weight_put (transaction, 3, 4); + ASSERT_EQ (0, store->online_weight.count (transaction)); + ASSERT_EQ (store->online_weight.end (), store->online_weight.begin (transaction)); + ASSERT_EQ (store->online_weight.end (), store->online_weight.rbegin (transaction)); + store->online_weight.put (transaction, 1, 2); + store->online_weight.put (transaction, 3, 4); } { auto transaction (store->tx_begin_write ()); - ASSERT_EQ (2, store->online_weight_count (transaction)); - auto item (store->online_weight_begin (transaction)); - ASSERT_NE (store->online_weight_end (), item); + ASSERT_EQ (2, store->online_weight.count (transaction)); + auto item (store->online_weight.begin (transaction)); + ASSERT_NE (store->online_weight.end (), item); ASSERT_EQ (1, item->first); ASSERT_EQ (2, item->second.number ()); - auto item_last (store->online_weight_rbegin (transaction)); - ASSERT_NE (store->online_weight_end (), item_last); + auto item_last (store->online_weight.rbegin (transaction)); + ASSERT_NE (store->online_weight.end (), item_last); ASSERT_EQ (3, item_last->first); ASSERT_EQ (4, item_last->second.number ()); - store->online_weight_del (transaction, 1); - ASSERT_EQ (1, store->online_weight_count (transaction)); - ASSERT_EQ (store->online_weight_begin (transaction), store->online_weight_rbegin (transaction)); - store->online_weight_del (transaction, 3); + store->online_weight.del (transaction, 1); + ASSERT_EQ (1, store->online_weight.count (transaction)); + ASSERT_EQ (store->online_weight.begin (transaction), store->online_weight.rbegin (transaction)); + store->online_weight.del (transaction, 3); } auto transaction (store->tx_begin_read ()); - ASSERT_EQ (0, store->online_weight_count (transaction)); - ASSERT_EQ (store->online_weight_end (), store->online_weight_begin (transaction)); - ASSERT_EQ (store->online_weight_end (), store->online_weight_rbegin (transaction)); + ASSERT_EQ (0, store->online_weight.count (transaction)); + ASSERT_EQ (store->online_weight.end (), store->online_weight.begin (transaction)); + ASSERT_EQ (store->online_weight.end (), store->online_weight.rbegin (transaction)); } TEST (block_store, pruned_blocks) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key1; @@ -1212,16 +1203,16 @@ TEST (block_store, pruned_blocks) auto transaction (store->tx_begin_write ()); // Confirm that the store is empty - ASSERT_FALSE (store->pruned_exists (transaction, hash1)); - ASSERT_EQ (store->pruned_count (transaction), 0); + ASSERT_FALSE (store->pruned.exists (transaction, hash1)); + ASSERT_EQ (store->pruned.count (transaction), 0); // Add one - store->pruned_put (transaction, hash1); - ASSERT_TRUE (store->pruned_exists (transaction, hash1)); + store->pruned.put (transaction, hash1); + ASSERT_TRUE (store->pruned.exists (transaction, hash1)); } // Confirm that it can be found - ASSERT_EQ (store->pruned_count (store->tx_begin_read ()), 1); + ASSERT_EQ (store->pruned.count (store->tx_begin_read ()), 1); // Add another one and check that it (and the existing one) can be found nano::open_block block2 (1, 2, key1.pub, key1.prv, key1.pub, 0); @@ -1229,155 +1220,153 @@ TEST (block_store, pruned_blocks) auto hash2 (block2.hash ()); { auto transaction (store->tx_begin_write ()); - store->pruned_put (transaction, hash2); - ASSERT_TRUE (store->pruned_exists (transaction, hash2)); // Check new pruned hash is here - ASSERT_FALSE (store->block_exists (transaction, hash2)); - ASSERT_TRUE (store->pruned_exists (transaction, hash1)); // Check first pruned hash is still here - ASSERT_FALSE (store->block_exists (transaction, hash1)); + store->pruned.put (transaction, hash2); + ASSERT_TRUE (store->pruned.exists (transaction, hash2)); // Check new pruned hash is here + ASSERT_FALSE (store->block.exists (transaction, hash2)); + ASSERT_TRUE (store->pruned.exists (transaction, hash1)); // Check first pruned hash is still here + ASSERT_FALSE (store->block.exists (transaction, hash1)); } - ASSERT_EQ (store->pruned_count (store->tx_begin_read ()), 2); + ASSERT_EQ (store->pruned.count (store->tx_begin_read ()), 2); // Delete the first one { auto transaction (store->tx_begin_write ()); - store->pruned_del (transaction, hash2); - ASSERT_FALSE (store->pruned_exists (transaction, hash2)); // Confirm it no longer exists - ASSERT_FALSE (store->block_exists (transaction, hash2)); // true for block_exists - store->block_put (transaction, hash2, block2); // Add corresponding block - ASSERT_TRUE (store->block_exists (transaction, hash2)); - ASSERT_TRUE (store->pruned_exists (transaction, hash1)); // Check first pruned hash is still here - ASSERT_FALSE (store->block_exists (transaction, hash1)); + store->pruned.del (transaction, hash2); + ASSERT_FALSE (store->pruned.exists (transaction, hash2)); // Confirm it no longer exists + ASSERT_FALSE (store->block.exists (transaction, hash2)); // true for block_exists + store->block.put (transaction, hash2, block2); // Add corresponding block + ASSERT_TRUE (store->block.exists (transaction, hash2)); + ASSERT_TRUE (store->pruned.exists (transaction, hash1)); // Check first pruned hash is still here + ASSERT_FALSE (store->block.exists (transaction, hash1)); } - ASSERT_EQ (store->pruned_count (store->tx_begin_read ()), 1); + ASSERT_EQ (store->pruned.count (store->tx_begin_read ()), 1); // Delete original one { auto transaction (store->tx_begin_write ()); - store->pruned_del (transaction, hash1); - ASSERT_FALSE (store->pruned_exists (transaction, hash1)); + store->pruned.del (transaction, hash1); + ASSERT_FALSE (store->pruned.exists (transaction, hash1)); } - ASSERT_EQ (store->pruned_count (store->tx_begin_read ()), 0); + ASSERT_EQ (store->pruned.count (store->tx_begin_read ()), 0); } TEST (mdb_block_store, upgrade_v14_v15) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; } // Extract confirmation height to a separate database auto path (nano::unique_path ()); - nano::genesis genesis; - nano::network_params network_params; - nano::work_pool pool (std::numeric_limits::max ()); - nano::send_block send (genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); - nano::state_block epoch (nano::dev_genesis_key.pub, send.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, network_params.ledger.epochs.link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send.hash ())); - nano::state_block state_send (nano::dev_genesis_key.pub, epoch.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio * 2, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch.hash ())); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::send_block send (nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); + nano::state_block epoch (nano::dev::genesis_key.pub, send.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::network_params.ledger.epochs.link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send.hash ())); + nano::state_block state_send (nano::dev::genesis_key.pub, epoch.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch.hash ())); { nano::logger_mt logger; - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); nano::stat stats; - nano::ledger ledger (store, stats); + nano::ledger ledger (store, stats, nano::dev::constants); auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis, ledger.cache); + store.initialize (transaction, ledger.cache); nano::account_info account_info; - ASSERT_FALSE (store.account_get (transaction, nano::genesis_account, account_info)); + ASSERT_FALSE (store.account.get (transaction, nano::dev::genesis->account (), account_info)); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store.confirmation_height_get (transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 1); - ASSERT_EQ (confirmation_height_info.frontier, genesis.hash ()); + ASSERT_EQ (confirmation_height_info.frontier, nano::dev::genesis->hash ()); // These databases get removed after an upgrade, so readd them - ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_v1", MDB_CREATE, &store.state_blocks_v1)); - ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "accounts_v1", MDB_CREATE, &store.accounts_v1)); - ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "pending_v1", MDB_CREATE, &store.pending_v1)); - ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks)); - ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "send", MDB_CREATE, &store.send_blocks)); - ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_blocks", MDB_CREATE, &store.state_blocks)); + ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_v1", MDB_CREATE, &store.state_blocks_v1_handle)); + ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "accounts_v1", MDB_CREATE, &store.accounts_v1_handle)); + ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "pending_v1", MDB_CREATE, &store.pending_v1_handle)); + ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle)); + ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "send", MDB_CREATE, &store.send_blocks_handle)); + ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_blocks", MDB_CREATE, &store.state_blocks_handle)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send).code); // Lower the database to the previous version - store.version_put (transaction, 14); - store.confirmation_height_del (transaction, nano::genesis_account); - modify_account_info_to_v14 (store, transaction, nano::genesis_account, confirmation_height_info.height, state_send.hash ()); + store.version.put (transaction, 14); + store.confirmation_height.del (transaction, nano::dev::genesis->account ()); + modify_account_info_to_v14 (store, transaction, nano::dev::genesis->account (), confirmation_height_info.height, state_send.hash ()); - store.pending_del (transaction, nano::pending_key (nano::genesis_account, state_send.hash ())); + store.pending.del (transaction, nano::pending_key (nano::dev::genesis->account (), state_send.hash ())); - write_sideband_v14 (store, transaction, state_send, store.state_blocks_v1); - write_sideband_v14 (store, transaction, epoch, store.state_blocks_v1); - write_block_w_sideband_v18 (store, store.open_blocks, transaction, *genesis.open); - write_block_w_sideband_v18 (store, store.send_blocks, transaction, send); + write_sideband_v14 (store, transaction, state_send, store.state_blocks_v1_handle); + write_sideband_v14 (store, transaction, epoch, store.state_blocks_v1_handle); + write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis); + write_block_w_sideband_v18 (store, store.send_blocks_handle, transaction, send); // Remove from blocks table - store.block_del (transaction, state_send.hash ()); - store.block_del (transaction, epoch.hash ()); + store.block.del (transaction, state_send.hash ()); + store.block.del (transaction, epoch.hash ()); // Turn pending into v14 - ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_v0, nano::mdb_val (nano::pending_key (nano::dev_genesis_key.pub, send.hash ())), nano::mdb_val (nano::pending_info_v14 (nano::genesis_account, nano::MBAN_ratio, nano::epoch::epoch_0)), 0)); - ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_v1, nano::mdb_val (nano::pending_key (nano::dev_genesis_key.pub, state_send.hash ())), nano::mdb_val (nano::pending_info_v14 (nano::genesis_account, nano::MBAN_ratio, nano::epoch::epoch_1)), 0)); + ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_v0_handle, nano::mdb_val (nano::pending_key (nano::dev::genesis_key.pub, send.hash ())), nano::mdb_val (nano::pending_info_v14 (nano::dev::genesis->account (), nano::MBAN_ratio, nano::epoch::epoch_0)), 0)); + ASSERT_FALSE (mdb_put (store.env.tx (transaction), store.pending_v1_handle, nano::mdb_val (nano::pending_key (nano::dev::genesis_key.pub, state_send.hash ())), nano::mdb_val (nano::pending_info_v14 (nano::dev::genesis->account (), nano::MBAN_ratio, nano::epoch::epoch_1)), 0)); // This should fail as sizes are no longer correct for account_info nano::mdb_val value; - ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.accounts_v1, nano::mdb_val (nano::genesis_account), value)); + ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.accounts_v1_handle, nano::mdb_val (nano::dev::genesis->account ()), value)); nano::account_info info; ASSERT_NE (value.size (), info.db_size ()); - store.account_del (transaction, nano::genesis_account); + store.account.del (transaction, nano::dev::genesis->account ()); // Confirmation height for the account should be deleted - ASSERT_TRUE (mdb_get (store.env.tx (transaction), store.confirmation_height, nano::mdb_val (nano::genesis_account), value)); + ASSERT_TRUE (mdb_get (store.env.tx (transaction), store.confirmation_height_handle, nano::mdb_val (nano::dev::genesis->account ()), value)); } // Now do the upgrade nano::logger_mt logger; - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); // Size of account_info should now equal that set in db nano::mdb_val value; - ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.accounts, nano::mdb_val (nano::genesis_account), value)); + ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.accounts_handle, nano::mdb_val (nano::dev::genesis->account ()), value)); nano::account_info info (value); ASSERT_EQ (value.size (), info.db_size ()); // Confirmation height should exist nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store.confirmation_height_get (transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 1); - ASSERT_EQ (confirmation_height_info.frontier, genesis.hash ()); + ASSERT_EQ (confirmation_height_info.frontier, nano::dev::genesis->hash ()); // accounts_v1, state_blocks_v1 & pending_v1 tables should be deleted - auto error_get_accounts_v1 (mdb_get (store.env.tx (transaction), store.accounts_v1, nano::mdb_val (nano::genesis_account), value)); + auto error_get_accounts_v1 (mdb_get (store.env.tx (transaction), store.accounts_v1_handle, nano::mdb_val (nano::dev::genesis->account ()), value)); ASSERT_NE (error_get_accounts_v1, MDB_SUCCESS); - auto error_get_pending_v1 (mdb_get (store.env.tx (transaction), store.pending_v1, nano::mdb_val (nano::pending_key (nano::dev_genesis_key.pub, state_send.hash ())), value)); + auto error_get_pending_v1 (mdb_get (store.env.tx (transaction), store.pending_v1_handle, nano::mdb_val (nano::pending_key (nano::dev::genesis_key.pub, state_send.hash ())), value)); ASSERT_NE (error_get_pending_v1, MDB_SUCCESS); - auto error_get_state_v1 (mdb_get (store.env.tx (transaction), store.state_blocks_v1, nano::mdb_val (state_send.hash ()), value)); + auto error_get_state_v1 (mdb_get (store.env.tx (transaction), store.state_blocks_v1_handle, nano::mdb_val (state_send.hash ()), value)); ASSERT_NE (error_get_state_v1, MDB_SUCCESS); // Check that the epochs are set correctly for the sideband, accounts and pending entries - auto block = store.block_get (transaction, state_send.hash ()); + auto block = store.block.get (transaction, state_send.hash ()); ASSERT_NE (block, nullptr); ASSERT_EQ (block->sideband ().details.epoch, nano::epoch::epoch_1); - block = store.block_get (transaction, send.hash ()); + block = store.block.get (transaction, send.hash ()); ASSERT_NE (block, nullptr); ASSERT_EQ (block->sideband ().details.epoch, nano::epoch::epoch_0); ASSERT_EQ (info.epoch (), nano::epoch::epoch_1); nano::pending_info pending_info; - store.pending_get (transaction, nano::pending_key (nano::dev_genesis_key.pub, send.hash ()), pending_info); + store.pending.get (transaction, nano::pending_key (nano::dev::genesis_key.pub, send.hash ()), pending_info); ASSERT_EQ (pending_info.epoch, nano::epoch::epoch_0); - store.pending_get (transaction, nano::pending_key (nano::dev_genesis_key.pub, state_send.hash ()), pending_info); + store.pending.get (transaction, nano::pending_key (nano::dev::genesis_key.pub, state_send.hash ()), pending_info); ASSERT_EQ (pending_info.epoch, nano::epoch::epoch_1); // Version should be correct - ASSERT_LT (14, store.version_get (transaction)); + ASSERT_LT (14, store.version.get (transaction)); } TEST (mdb_block_store, upgrade_v15_v16) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; @@ -1385,101 +1374,98 @@ TEST (mdb_block_store, upgrade_v15_v16) auto path (nano::unique_path ()); nano::mdb_val value; { - nano::genesis genesis; nano::logger_mt logger; - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); nano::stat stats; - nano::ledger ledger (store, stats); + nano::ledger ledger (store, stats, nano::dev::constants); auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis, ledger.cache); + store.initialize (transaction, ledger.cache); // The representation table should get removed after, so readd it so that we can later confirm this actually happens auto txn = store.env.tx (transaction); - ASSERT_FALSE (mdb_dbi_open (txn, "representation", MDB_CREATE, &store.representation)); - auto weight = ledger.cache.rep_weights.representation_get (nano::genesis_account); - ASSERT_EQ (MDB_SUCCESS, mdb_put (txn, store.representation, nano::mdb_val (nano::genesis_account), nano::mdb_val (nano::uint128_union (weight)), 0)); - ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks)); - write_block_w_sideband_v18 (store, store.open_blocks, transaction, *genesis.open); + ASSERT_FALSE (mdb_dbi_open (txn, "representation", MDB_CREATE, &store.representation_handle)); + auto weight = ledger.cache.rep_weights.representation_get (nano::dev::genesis->account ()); + ASSERT_EQ (MDB_SUCCESS, mdb_put (txn, store.representation_handle, nano::mdb_val (nano::dev::genesis->account ()), nano::mdb_val (nano::uint128_union (weight)), 0)); + ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle)); + write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis); // Lower the database to the previous version - store.version_put (transaction, 15); + store.version.put (transaction, 15); // Confirm the rep weight exists in the database - ASSERT_EQ (MDB_SUCCESS, mdb_get (store.env.tx (transaction), store.representation, nano::mdb_val (nano::genesis_account), value)); - store.confirmation_height_del (transaction, nano::genesis_account); + ASSERT_EQ (MDB_SUCCESS, mdb_get (store.env.tx (transaction), store.representation_handle, nano::mdb_val (nano::dev::genesis->account ()), value)); + store.confirmation_height.del (transaction, nano::dev::genesis->account ()); } // Now do the upgrade nano::logger_mt logger; - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); // The representation table should now be deleted - auto error_get_representation (mdb_get (store.env.tx (transaction), store.representation, nano::mdb_val (nano::genesis_account), value)); + auto error_get_representation (mdb_get (store.env.tx (transaction), store.representation_handle, nano::mdb_val (nano::dev::genesis->account ()), value)); ASSERT_NE (MDB_SUCCESS, error_get_representation); - ASSERT_EQ (store.representation, 0); + ASSERT_EQ (store.representation_handle, 0); // Version should be correct - ASSERT_LT (15, store.version_get (transaction)); + ASSERT_LT (15, store.version.get (transaction)); } TEST (mdb_block_store, upgrade_v16_v17) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; } - nano::genesis genesis; - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block block1 (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); - nano::state_block block2 (nano::dev_genesis_key.pub, block1.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio - 1, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ())); - nano::state_block block3 (nano::dev_genesis_key.pub, block2.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio - 2, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block2.hash ())); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block block1 (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); + nano::state_block block2 (nano::dev::genesis_key.pub, block1.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio - 1, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block1.hash ())); + nano::state_block block3 (nano::dev::genesis_key.pub, block2.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio - 2, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block2.hash ())); auto code = [&block1, &block2, &block3] (auto confirmation_height, nano::block_hash const & expected_cemented_frontier) { auto path (nano::unique_path ()); nano::mdb_val value; { - nano::genesis genesis; nano::logger_mt logger; - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); nano::stat stats; - nano::ledger ledger (store, stats); + nano::ledger ledger (store, stats, nano::dev::constants); auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis, ledger.cache); + store.initialize (transaction, ledger.cache); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code); - modify_confirmation_height_to_v15 (store, transaction, nano::genesis_account, confirmation_height); + modify_confirmation_height_to_v15 (store, transaction, nano::dev::genesis->account (), confirmation_height); - ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks)); - write_block_w_sideband_v18 (store, store.open_blocks, transaction, *genesis.open); - ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_blocks", MDB_CREATE, &store.state_blocks)); - write_block_w_sideband_v18 (store, store.state_blocks, transaction, block1); - write_block_w_sideband_v18 (store, store.state_blocks, transaction, block2); - write_block_w_sideband_v18 (store, store.state_blocks, transaction, block3); + ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle)); + write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis); + ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_blocks", MDB_CREATE, &store.state_blocks_handle)); + write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, block1); + write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, block2); + write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, block3); // Lower the database to the previous version - store.version_put (transaction, 16); + store.version.put (transaction, 16); } // Now do the upgrade nano::logger_mt logger; - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store.confirmation_height_get (transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (store.confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, confirmation_height); // Check confirmation height frontier is correct ASSERT_EQ (confirmation_height_info.frontier, expected_cemented_frontier); // Version should be correct - ASSERT_LT (16, store.version_get (transaction)); + ASSERT_LT (16, store.version.get (transaction)); }; code (0, nano::block_hash (0)); - code (1, genesis.hash ()); + code (1, nano::dev::genesis->hash ()); code (2, block1.hash ()); code (3, block2.hash ()); code (4, block3.hash ()); @@ -1487,37 +1473,35 @@ TEST (mdb_block_store, upgrade_v16_v17) TEST (mdb_block_store, upgrade_v17_v18) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; } auto path (nano::unique_path ()); - nano::genesis genesis; nano::keypair key1; nano::keypair key2; nano::keypair key3; - nano::network_params network_params; - nano::work_pool pool (std::numeric_limits::max ()); - nano::send_block send_zero (genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); - nano::state_block state_receive_zero (nano::dev_genesis_key.pub, send_zero.hash (), nano::dev_genesis_key.pub, nano::genesis_amount, send_zero.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send_zero.hash ())); - nano::state_block epoch (nano::dev_genesis_key.pub, state_receive_zero.hash (), nano::dev_genesis_key.pub, nano::genesis_amount, network_params.ledger.epochs.link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (state_receive_zero.hash ())); - nano::state_block state_send (nano::dev_genesis_key.pub, epoch.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch.hash ())); - nano::state_block state_receive (nano::dev_genesis_key.pub, state_send.hash (), nano::dev_genesis_key.pub, nano::genesis_amount, state_send.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (state_send.hash ())); - nano::state_block state_change (nano::dev_genesis_key.pub, state_receive.hash (), nano::dev_genesis_key.pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (state_receive.hash ())); - nano::state_block state_send_change (nano::dev_genesis_key.pub, state_change.hash (), key1.pub, nano::genesis_amount - nano::MBAN_ratio, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (state_change.hash ())); - nano::state_block epoch_first (key1.pub, 0, 0, 0, network_params.ledger.epochs.link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (key1.pub)); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::send_block send_zero (nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); + nano::state_block state_receive_zero (nano::dev::genesis_key.pub, send_zero.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, send_zero.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send_zero.hash ())); + nano::state_block epoch (nano::dev::genesis_key.pub, state_receive_zero.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, nano::dev::network_params.ledger.epochs.link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_receive_zero.hash ())); + nano::state_block state_send (nano::dev::genesis_key.pub, epoch.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch.hash ())); + nano::state_block state_receive (nano::dev::genesis_key.pub, state_send.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, state_send.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_send.hash ())); + nano::state_block state_change (nano::dev::genesis_key.pub, state_receive.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_receive.hash ())); + nano::state_block state_send_change (nano::dev::genesis_key.pub, state_change.hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_change.hash ())); + nano::state_block epoch_first (key1.pub, 0, 0, 0, nano::dev::network_params.ledger.epochs.link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (key1.pub)); nano::state_block state_receive2 (key1.pub, epoch_first.hash (), key1.pub, nano::MBAN_ratio, state_send_change.hash (), key1.prv, key1.pub, *pool.generate (epoch_first.hash ())); - nano::state_block state_send2 (nano::dev_genesis_key.pub, state_send_change.hash (), key1.pub, nano::genesis_amount - nano::MBAN_ratio * 2, key2.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (state_send_change.hash ())); + nano::state_block state_send2 (nano::dev::genesis_key.pub, state_send_change.hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_send_change.hash ())); nano::state_block state_open (key2.pub, 0, key2.pub, nano::MBAN_ratio, state_send2.hash (), key2.prv, key2.pub, *pool.generate (key2.pub)); - nano::state_block state_send_epoch_link (key2.pub, state_open.hash (), key2.pub, 0, network_params.ledger.epochs.link (nano::epoch::epoch_2), key2.prv, key2.pub, *pool.generate (state_open.hash ())); + nano::state_block state_send_epoch_link (key2.pub, state_open.hash (), key2.pub, 0, nano::dev::network_params.ledger.epochs.link (nano::epoch::epoch_2), key2.prv, key2.pub, *pool.generate (state_open.hash ())); { nano::logger_mt logger; - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); auto transaction (store.tx_begin_write ()); nano::stat stats; - nano::ledger ledger (store, stats); - store.initialize (transaction, genesis, ledger.cache); + nano::ledger ledger (store, stats, nano::dev::constants); + store.initialize (transaction, ledger.cache); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send_zero).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_receive_zero).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch).code); @@ -1531,19 +1515,19 @@ TEST (mdb_block_store, upgrade_v17_v18) ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_open).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, state_send_epoch_link).code); - ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks)); - ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "send", MDB_CREATE, &store.send_blocks)); - ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_blocks", MDB_CREATE, &store.state_blocks)); + ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "open", MDB_CREATE, &store.open_blocks_handle)); + ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "send", MDB_CREATE, &store.send_blocks_handle)); + ASSERT_FALSE (mdb_dbi_open (store.env.tx (transaction), "state_blocks", MDB_CREATE, &store.state_blocks_handle)); // Downgrade the store - store.version_put (transaction, 17); + store.version.put (transaction, 17); - write_block_w_sideband_v18 (store, store.state_blocks, transaction, state_receive); - write_block_w_sideband_v18 (store, store.state_blocks, transaction, epoch_first); - write_block_w_sideband_v18 (store, store.state_blocks, transaction, state_send2); - write_block_w_sideband_v18 (store, store.state_blocks, transaction, state_send_epoch_link); - write_block_w_sideband_v18 (store, store.open_blocks, transaction, *genesis.open); - write_block_w_sideband_v18 (store, store.send_blocks, transaction, send_zero); + write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, state_receive); + write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, epoch_first); + write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, state_send2); + write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, state_send_epoch_link); + write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis); + write_block_w_sideband_v18 (store, store.send_blocks_handle, transaction, send_zero); // Replace with the previous sideband version for state blocks // The upgrade can resume after upgrading some blocks, test this by only downgrading some of them @@ -1555,30 +1539,30 @@ TEST (mdb_block_store, upgrade_v17_v18) write_sideband_v15 (store, transaction, state_receive2); write_sideband_v15 (store, transaction, state_open); - store.block_del (transaction, state_receive_zero.hash ()); - store.block_del (transaction, epoch.hash ()); - store.block_del (transaction, state_send.hash ()); - store.block_del (transaction, state_change.hash ()); - store.block_del (transaction, state_send_change.hash ()); - store.block_del (transaction, state_receive2.hash ()); - store.block_del (transaction, state_open.hash ()); + store.block.del (transaction, state_receive_zero.hash ()); + store.block.del (transaction, epoch.hash ()); + store.block.del (transaction, state_send.hash ()); + store.block.del (transaction, state_change.hash ()); + store.block.del (transaction, state_send_change.hash ()); + store.block.del (transaction, state_receive2.hash ()); + store.block.del (transaction, state_open.hash ()); } // Now do the upgrade nano::logger_mt logger; - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); // Size of state block should equal that set in db (no change) nano::mdb_val value; - ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.blocks, nano::mdb_val (state_send.hash ()), value)); + ASSERT_FALSE (mdb_get (store.env.tx (transaction), store.blocks_handle, nano::mdb_val (state_send.hash ()), value)); ASSERT_EQ (value.size (), sizeof (nano::block_type) + nano::state_block::size + nano::block_sideband::size (nano::block_type::state)); // Check that sidebands are correctly populated { // Non-state unaffected - auto block = store.block_get (transaction, send_zero.hash ()); + auto block = store.block.get (transaction, send_zero.hash ()); ASSERT_NE (block, nullptr); // All defaults ASSERT_EQ (block->sideband ().details.epoch, nano::epoch::epoch_0); @@ -1588,7 +1572,7 @@ TEST (mdb_block_store, upgrade_v17_v18) } { // State receive from old zero send - auto block = store.block_get (transaction, state_receive_zero.hash ()); + auto block = store.block.get (transaction, state_receive_zero.hash ()); ASSERT_NE (block, nullptr); ASSERT_EQ (block->sideband ().details.epoch, nano::epoch::epoch_0); ASSERT_FALSE (block->sideband ().details.is_epoch); @@ -1597,7 +1581,7 @@ TEST (mdb_block_store, upgrade_v17_v18) } { // Epoch - auto block = store.block_get (transaction, epoch.hash ()); + auto block = store.block.get (transaction, epoch.hash ()); ASSERT_NE (block, nullptr); ASSERT_EQ (block->sideband ().details.epoch, nano::epoch::epoch_1); ASSERT_TRUE (block->sideband ().details.is_epoch); @@ -1606,7 +1590,7 @@ TEST (mdb_block_store, upgrade_v17_v18) } { // State send - auto block = store.block_get (transaction, state_send.hash ()); + auto block = store.block.get (transaction, state_send.hash ()); ASSERT_NE (block, nullptr); ASSERT_EQ (block->sideband ().details.epoch, nano::epoch::epoch_1); ASSERT_FALSE (block->sideband ().details.is_epoch); @@ -1615,7 +1599,7 @@ TEST (mdb_block_store, upgrade_v17_v18) } { // State receive - auto block = store.block_get (transaction, state_receive.hash ()); + auto block = store.block.get (transaction, state_receive.hash ()); ASSERT_NE (block, nullptr); ASSERT_EQ (block->sideband ().details.epoch, nano::epoch::epoch_1); ASSERT_FALSE (block->sideband ().details.is_epoch); @@ -1624,7 +1608,7 @@ TEST (mdb_block_store, upgrade_v17_v18) } { // State change - auto block = store.block_get (transaction, state_change.hash ()); + auto block = store.block.get (transaction, state_change.hash ()); ASSERT_NE (block, nullptr); ASSERT_EQ (block->sideband ().details.epoch, nano::epoch::epoch_1); ASSERT_FALSE (block->sideband ().details.is_epoch); @@ -1633,7 +1617,7 @@ TEST (mdb_block_store, upgrade_v17_v18) } { // State send + change - auto block = store.block_get (transaction, state_send_change.hash ()); + auto block = store.block.get (transaction, state_send_change.hash ()); ASSERT_NE (block, nullptr); ASSERT_EQ (block->sideband ().details.epoch, nano::epoch::epoch_1); ASSERT_FALSE (block->sideband ().details.is_epoch); @@ -1642,7 +1626,7 @@ TEST (mdb_block_store, upgrade_v17_v18) } { // Epoch on unopened account - auto block = store.block_get (transaction, epoch_first.hash ()); + auto block = store.block.get (transaction, epoch_first.hash ()); ASSERT_NE (block, nullptr); ASSERT_EQ (block->sideband ().details.epoch, nano::epoch::epoch_2); ASSERT_TRUE (block->sideband ().details.is_epoch); @@ -1651,7 +1635,7 @@ TEST (mdb_block_store, upgrade_v17_v18) } { // State open following epoch - auto block = store.block_get (transaction, state_receive2.hash ()); + auto block = store.block.get (transaction, state_receive2.hash ()); ASSERT_NE (block, nullptr); ASSERT_EQ (block->sideband ().details.epoch, nano::epoch::epoch_2); ASSERT_FALSE (block->sideband ().details.is_epoch); @@ -1660,7 +1644,7 @@ TEST (mdb_block_store, upgrade_v17_v18) } { // Another state send - auto block = store.block_get (transaction, state_send2.hash ()); + auto block = store.block.get (transaction, state_send2.hash ()); ASSERT_NE (block, nullptr); ASSERT_EQ (block->sideband ().details.epoch, nano::epoch::epoch_1); ASSERT_FALSE (block->sideband ().details.is_epoch); @@ -1669,7 +1653,7 @@ TEST (mdb_block_store, upgrade_v17_v18) } { // State open - auto block = store.block_get (transaction, state_open.hash ()); + auto block = store.block.get (transaction, state_open.hash ()); ASSERT_NE (block, nullptr); ASSERT_EQ (block->sideband ().details.epoch, nano::epoch::epoch_1); ASSERT_FALSE (block->sideband ().details.is_epoch); @@ -1678,7 +1662,7 @@ TEST (mdb_block_store, upgrade_v17_v18) } { // State send to an epoch link - auto block = store.block_get (transaction, state_send_epoch_link.hash ()); + auto block = store.block.get (transaction, state_send_epoch_link.hash ()); ASSERT_NE (block, nullptr); ASSERT_EQ (block->sideband ().details.epoch, nano::epoch::epoch_1); ASSERT_FALSE (block->sideband ().details.is_epoch); @@ -1686,35 +1670,33 @@ TEST (mdb_block_store, upgrade_v17_v18) ASSERT_FALSE (block->sideband ().details.is_receive); } // Version should be correct - ASSERT_LT (17, store.version_get (transaction)); + ASSERT_LT (17, store.version.get (transaction)); } TEST (mdb_block_store, upgrade_v18_v19) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; } auto path (nano::unique_path ()); nano::keypair key1; - nano::work_pool pool (std::numeric_limits::max ()); - nano::network_params network_params; - nano::send_block send (nano::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::genesis_hash)); - nano::receive_block receive (send.hash (), send.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send.hash ())); - nano::change_block change (receive.hash (), 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (receive.hash ())); - nano::state_block state_epoch (nano::dev_genesis_key.pub, change.hash (), 0, nano::genesis_amount, network_params.ledger.epochs.link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (change.hash ())); - nano::state_block state_send (nano::dev_genesis_key.pub, state_epoch.hash (), 0, nano::genesis_amount - nano::MBAN_ratio, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (state_epoch.hash ())); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::send_block send (nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); + nano::receive_block receive (send.hash (), send.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send.hash ())); + nano::change_block change (receive.hash (), 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (receive.hash ())); + nano::state_block state_epoch (nano::dev::genesis_key.pub, change.hash (), 0, nano::dev::constants.genesis_amount, nano::dev::network_params.ledger.epochs.link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (change.hash ())); + nano::state_block state_send (nano::dev::genesis_key.pub, state_epoch.hash (), 0, nano::dev::constants.genesis_amount - nano::MBAN_ratio, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (state_epoch.hash ())); nano::state_block state_open (key1.pub, 0, 0, nano::MBAN_ratio, state_send.hash (), key1.prv, key1.pub, *pool.generate (key1.pub)); { - nano::genesis genesis; nano::logger_mt logger; - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); nano::stat stats; - nano::ledger ledger (store, stats); + nano::ledger ledger (store, stats, nano::dev::constants); auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis, ledger.cache); + store.initialize (transaction, ledger.cache); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code); @@ -1725,126 +1707,124 @@ TEST (mdb_block_store, upgrade_v18_v19) // These tables need to be re-opened and populated so that an upgrade can be done auto txn = store.env.tx (transaction); - ASSERT_FALSE (mdb_dbi_open (txn, "open", MDB_CREATE, &store.open_blocks)); - ASSERT_FALSE (mdb_dbi_open (txn, "receive", MDB_CREATE, &store.receive_blocks)); - ASSERT_FALSE (mdb_dbi_open (txn, "send", MDB_CREATE, &store.send_blocks)); - ASSERT_FALSE (mdb_dbi_open (txn, "change", MDB_CREATE, &store.change_blocks)); - ASSERT_FALSE (mdb_dbi_open (txn, "state_blocks", MDB_CREATE, &store.state_blocks)); + ASSERT_FALSE (mdb_dbi_open (txn, "open", MDB_CREATE, &store.open_blocks_handle)); + ASSERT_FALSE (mdb_dbi_open (txn, "receive", MDB_CREATE, &store.receive_blocks_handle)); + ASSERT_FALSE (mdb_dbi_open (txn, "send", MDB_CREATE, &store.send_blocks_handle)); + ASSERT_FALSE (mdb_dbi_open (txn, "change", MDB_CREATE, &store.change_blocks_handle)); + ASSERT_FALSE (mdb_dbi_open (txn, "state_blocks", MDB_CREATE, &store.state_blocks_handle)); // Modify blocks back to the old tables - write_block_w_sideband_v18 (store, store.open_blocks, transaction, *genesis.open); - write_block_w_sideband_v18 (store, store.send_blocks, transaction, send); - write_block_w_sideband_v18 (store, store.receive_blocks, transaction, receive); - write_block_w_sideband_v18 (store, store.change_blocks, transaction, change); - write_block_w_sideband_v18 (store, store.state_blocks, transaction, state_epoch); - write_block_w_sideband_v18 (store, store.state_blocks, transaction, state_send); - write_block_w_sideband_v18 (store, store.state_blocks, transaction, state_open); + write_block_w_sideband_v18 (store, store.open_blocks_handle, transaction, *nano::dev::genesis); + write_block_w_sideband_v18 (store, store.send_blocks_handle, transaction, send); + write_block_w_sideband_v18 (store, store.receive_blocks_handle, transaction, receive); + write_block_w_sideband_v18 (store, store.change_blocks_handle, transaction, change); + write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, state_epoch); + write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, state_send); + write_block_w_sideband_v18 (store, store.state_blocks_handle, transaction, state_open); - store.version_put (transaction, 18); + store.version.put (transaction, 18); } // Now do the upgrade nano::logger_mt logger; - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); // These tables should be deleted - ASSERT_EQ (store.send_blocks, 0); - ASSERT_EQ (store.receive_blocks, 0); - ASSERT_EQ (store.change_blocks, 0); - ASSERT_EQ (store.open_blocks, 0); - ASSERT_EQ (store.state_blocks, 0); + ASSERT_EQ (store.send_blocks_handle, 0); + ASSERT_EQ (store.receive_blocks_handle, 0); + ASSERT_EQ (store.change_blocks_handle, 0); + ASSERT_EQ (store.open_blocks_handle, 0); + ASSERT_EQ (store.state_blocks_handle, 0); // Confirm these blocks all exist after the upgrade - ASSERT_TRUE (store.block_get (transaction, send.hash ())); - ASSERT_TRUE (store.block_get (transaction, receive.hash ())); - ASSERT_TRUE (store.block_get (transaction, change.hash ())); - ASSERT_TRUE (store.block_get (transaction, nano::genesis_hash)); - auto state_epoch_disk (store.block_get (transaction, state_epoch.hash ())); + ASSERT_TRUE (store.block.get (transaction, send.hash ())); + ASSERT_TRUE (store.block.get (transaction, receive.hash ())); + ASSERT_TRUE (store.block.get (transaction, change.hash ())); + ASSERT_TRUE (store.block.get (transaction, nano::dev::genesis->hash ())); + auto state_epoch_disk (store.block.get (transaction, state_epoch.hash ())); ASSERT_NE (nullptr, state_epoch_disk); ASSERT_EQ (nano::epoch::epoch_1, state_epoch_disk->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, state_epoch_disk->sideband ().source_epoch); // Not used for epoch state blocks - ASSERT_TRUE (store.block_get (transaction, state_send.hash ())); - auto state_send_disk (store.block_get (transaction, state_send.hash ())); + ASSERT_TRUE (store.block.get (transaction, state_send.hash ())); + auto state_send_disk (store.block.get (transaction, state_send.hash ())); ASSERT_NE (nullptr, state_send_disk); ASSERT_EQ (nano::epoch::epoch_1, state_send_disk->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, state_send_disk->sideband ().source_epoch); // Not used for send state blocks - ASSERT_TRUE (store.block_get (transaction, state_open.hash ())); - auto state_open_disk (store.block_get (transaction, state_open.hash ())); + ASSERT_TRUE (store.block.get (transaction, state_open.hash ())); + auto state_open_disk (store.block.get (transaction, state_open.hash ())); ASSERT_NE (nullptr, state_open_disk); ASSERT_EQ (nano::epoch::epoch_1, state_open_disk->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_1, state_open_disk->sideband ().source_epoch); - ASSERT_EQ (7, store.count (transaction, store.blocks)); + ASSERT_EQ (7, store.count (transaction, store.blocks_handle)); // Version should be correct - ASSERT_LT (18, store.version_get (transaction)); + ASSERT_LT (18, store.version.get (transaction)); } TEST (mdb_block_store, upgrade_v19_v20) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; } auto path (nano::unique_path ()); - nano::genesis genesis; nano::logger_mt logger; nano::stat stats; { - nano::mdb_store store (logger, path); - nano::ledger ledger (store, stats); + nano::mdb_store store (logger, path, nano::dev::constants); + nano::ledger ledger (store, stats, nano::dev::constants); auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis, ledger.cache); + store.initialize (transaction, ledger.cache); // Delete pruned table - ASSERT_FALSE (mdb_drop (store.env.tx (transaction), store.pruned, 1)); - store.version_put (transaction, 19); + ASSERT_FALSE (mdb_drop (store.env.tx (transaction), store.pruned_handle, 1)); + store.version.put (transaction, 19); } // Upgrading should create the table - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); ASSERT_FALSE (store.init_error ()); - ASSERT_NE (store.pruned, 0); + ASSERT_NE (store.pruned_handle, 0); // Version should be correct auto transaction (store.tx_begin_read ()); - ASSERT_LT (19, store.version_get (transaction)); + ASSERT_LT (19, store.version.get (transaction)); } TEST (mdb_block_store, upgrade_v20_v21) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; } auto path (nano::unique_path ()); - nano::genesis genesis; nano::logger_mt logger; nano::stat stats; { - nano::mdb_store store (logger, path); - nano::ledger ledger (store, stats); + nano::mdb_store store (logger, path, nano::dev::constants); + nano::ledger ledger (store, stats, nano::dev::constants); auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis, ledger.cache); + store.initialize (transaction, ledger.cache); // Delete pruned table - ASSERT_FALSE (mdb_drop (store.env.tx (transaction), store.final_votes, 1)); - store.version_put (transaction, 20); + ASSERT_FALSE (mdb_drop (store.env.tx (transaction), store.final_votes_handle, 1)); + store.version.put (transaction, 20); } // Upgrading should create the table - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); ASSERT_FALSE (store.init_error ()); - ASSERT_NE (store.final_votes, 0); + ASSERT_NE (store.final_votes_handle, 0); // Version should be correct auto transaction (store.tx_begin_read ()); - ASSERT_LT (19, store.version_get (transaction)); + ASSERT_LT (19, store.version.get (transaction)); } TEST (mdb_block_store, upgrade_backup) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; @@ -1867,95 +1847,94 @@ TEST (mdb_block_store, upgrade_backup) { nano::logger_mt logger; - nano::genesis genesis; - nano::mdb_store store (logger, path); + nano::mdb_store store (logger, path, nano::dev::constants); auto transaction (store.tx_begin_write ()); - store.version_put (transaction, 14); + store.version.put (transaction, 14); } ASSERT_EQ (get_backup_path ().string (), dir.string ()); // Now do the upgrade and confirm that backup is saved nano::logger_mt logger; - nano::mdb_store store (logger, path, nano::txn_tracking_config{}, std::chrono::seconds (5), nano::lmdb_config{}, true); + nano::mdb_store store (logger, path, nano::dev::constants, nano::txn_tracking_config{}, std::chrono::seconds (5), nano::lmdb_config{}, true); ASSERT_FALSE (store.init_error ()); auto transaction (store.tx_begin_read ()); - ASSERT_LT (14, store.version_get (transaction)); + ASSERT_LT (14, store.version.get (transaction)); ASSERT_NE (get_backup_path ().string (), dir.string ()); } // Test various confirmation height values as well as clearing them TEST (block_store, confirmation_height) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; } auto path (nano::unique_path ()); nano::logger_mt logger; - auto store = nano::make_store (logger, path); + auto store = nano::make_store (logger, path, nano::dev::constants); - nano::account account1 (0); - nano::account account2 (1); - nano::account account3 (2); + nano::account account1{}; + nano::account account2{ 1 }; + nano::account account3{ 2 }; nano::block_hash cemented_frontier1 (3); nano::block_hash cemented_frontier2 (4); nano::block_hash cemented_frontier3 (5); { auto transaction (store->tx_begin_write ()); - store->confirmation_height_put (transaction, account1, { 500, cemented_frontier1 }); - store->confirmation_height_put (transaction, account2, { std::numeric_limits::max (), cemented_frontier2 }); - store->confirmation_height_put (transaction, account3, { 10, cemented_frontier3 }); + store->confirmation_height.put (transaction, account1, { 500, cemented_frontier1 }); + store->confirmation_height.put (transaction, account2, { std::numeric_limits::max (), cemented_frontier2 }); + store->confirmation_height.put (transaction, account3, { 10, cemented_frontier3 }); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store->confirmation_height_get (transaction, account1, confirmation_height_info)); + ASSERT_FALSE (store->confirmation_height.get (transaction, account1, confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 500); ASSERT_EQ (confirmation_height_info.frontier, cemented_frontier1); - ASSERT_FALSE (store->confirmation_height_get (transaction, account2, confirmation_height_info)); + ASSERT_FALSE (store->confirmation_height.get (transaction, account2, confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, std::numeric_limits::max ()); ASSERT_EQ (confirmation_height_info.frontier, cemented_frontier2); - ASSERT_FALSE (store->confirmation_height_get (transaction, account3, confirmation_height_info)); + ASSERT_FALSE (store->confirmation_height.get (transaction, account3, confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 10); ASSERT_EQ (confirmation_height_info.frontier, cemented_frontier3); // Check clearing of confirmation heights - store->confirmation_height_clear (transaction); + store->confirmation_height.clear (transaction); } auto transaction (store->tx_begin_read ()); - ASSERT_EQ (store->confirmation_height_count (transaction), 0); + ASSERT_EQ (store->confirmation_height.count (transaction), 0); nano::confirmation_height_info confirmation_height_info; - ASSERT_TRUE (store->confirmation_height_get (transaction, account1, confirmation_height_info)); - ASSERT_TRUE (store->confirmation_height_get (transaction, account2, confirmation_height_info)); - ASSERT_TRUE (store->confirmation_height_get (transaction, account3, confirmation_height_info)); + ASSERT_TRUE (store->confirmation_height.get (transaction, account1, confirmation_height_info)); + ASSERT_TRUE (store->confirmation_height.get (transaction, account2, confirmation_height_info)); + ASSERT_TRUE (store->confirmation_height.get (transaction, account3, confirmation_height_info)); } // Test various confirmation height values as well as clearing them TEST (block_store, final_vote) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode as deletions cause inaccurate counts return; } auto path (nano::unique_path ()); nano::logger_mt logger; - auto store = nano::make_store (logger, path); + auto store = nano::make_store (logger, path, nano::dev::constants); { - auto qualified_root = nano::genesis ().open->qualified_root (); + auto qualified_root = nano::dev::genesis->qualified_root (); auto transaction (store->tx_begin_write ()); - store->final_vote_put (transaction, qualified_root, nano::block_hash (2)); - ASSERT_EQ (store->final_vote_count (transaction), 1); - store->final_vote_clear (transaction); - ASSERT_EQ (store->final_vote_count (transaction), 0); - store->final_vote_put (transaction, qualified_root, nano::block_hash (2)); - ASSERT_EQ (store->final_vote_count (transaction), 1); + store->final_vote.put (transaction, qualified_root, nano::block_hash (2)); + ASSERT_EQ (store->final_vote.count (transaction), 1); + store->final_vote.clear (transaction); + ASSERT_EQ (store->final_vote.count (transaction), 0); + store->final_vote.put (transaction, qualified_root, nano::block_hash (2)); + ASSERT_EQ (store->final_vote.count (transaction), 1); // Clearing with incorrect root shouldn't remove - store->final_vote_clear (transaction, qualified_root.previous ()); - ASSERT_EQ (store->final_vote_count (transaction), 1); + store->final_vote.clear (transaction, qualified_root.previous ()); + ASSERT_EQ (store->final_vote.count (transaction), 1); // Clearing with correct root should remove - store->final_vote_clear (transaction, qualified_root.root ()); - ASSERT_EQ (store->final_vote_count (transaction), 0); + store->final_vote.clear (transaction, qualified_root.root ()); + ASSERT_EQ (store->final_vote.count (transaction), 0); } } @@ -1965,21 +1944,21 @@ TEST (block_store, incompatible_version) auto path (nano::unique_path ()); nano::logger_mt logger; { - auto store = nano::make_store (logger, path); + auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_FALSE (store->init_error ()); // Put version to an unreachable number so that it should always be incompatible auto transaction (store->tx_begin_write ()); - store->version_put (transaction, std::numeric_limits::max ()); + store->version.put (transaction, std::numeric_limits::max ()); } // Now try and read it, should give an error { - auto store = nano::make_store (logger, path, true); + auto store = nano::make_store (logger, path, nano::dev::constants, true); ASSERT_TRUE (store->init_error ()); auto transaction = store->tx_begin_read (); - auto version_l = store->version_get (transaction); + auto version_l = store->version.get (transaction); ASSERT_EQ (version_l, std::numeric_limits::max ()); } } @@ -1987,7 +1966,7 @@ TEST (block_store, incompatible_version) TEST (block_store, reset_renew_existing_transaction) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::keypair key1; @@ -1997,7 +1976,7 @@ TEST (block_store, reset_renew_existing_transaction) auto read_transaction = store->tx_begin_read (); // Block shouldn't exist yet - auto block_non_existing (store->block_get (read_transaction, hash1)); + auto block_non_existing (store->block.get (read_transaction, hash1)); ASSERT_EQ (nullptr, block_non_existing); // Release resources for the transaction @@ -2006,13 +1985,13 @@ TEST (block_store, reset_renew_existing_transaction) // Write the block { auto write_transaction (store->tx_begin_write ()); - store->block_put (write_transaction, hash1, block); + store->block.put (write_transaction, hash1, block); } read_transaction.renew (); // Block should exist now - auto block_existing (store->block_get (read_transaction, hash1)); + auto block_existing (store->block.get (read_transaction, hash1)); ASSERT_NE (nullptr, block_existing); } @@ -2024,7 +2003,7 @@ TEST (block_store, rocksdb_force_test_env_variable) constexpr auto env_var = "TEST_USE_ROCKSDB"; auto value = std::getenv (env_var); - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); auto mdb_cast = dynamic_cast (store.get ()); if (value && boost::lexical_cast (value) == 1) @@ -2041,16 +2020,16 @@ namespace nano { TEST (rocksdb_block_store, tombstone_count) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { nano::logger_mt logger; - auto store = std::make_unique (logger, nano::unique_path ()); + auto store = std::make_unique (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); auto transaction = store->tx_begin_write (); auto block1 (std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5)); - store->unchecked_put (transaction, block1->previous (), block1); + store->unchecked.put (transaction, block1->previous (), block1); ASSERT_EQ (store->tombstone_map.at (nano::tables::unchecked).num_since_last_flush.load (), 0); - store->unchecked_del (transaction, nano::unchecked_key (block1->previous (), block1->hash ())); + store->unchecked.del (transaction, nano::unchecked_key (block1->previous (), block1->hash ())); ASSERT_EQ (store->tombstone_map.at (nano::tables::unchecked).num_since_last_flush.load (), 1); } } @@ -2060,7 +2039,7 @@ namespace { void write_sideband_v14 (nano::mdb_store & store_a, nano::transaction & transaction_a, nano::block const & block_a, MDB_dbi db_a) { - auto block = store_a.block_get (transaction_a, block_a.hash ()); + auto block = store_a.block.get (transaction_a, block_a.hash ()); ASSERT_NE (block, nullptr); nano::block_sideband_v14 sideband_v14 (block->type (), block->sideband ().account, block->sideband ().successor, block->sideband ().balance, block->sideband ().timestamp, block->sideband ().height); @@ -2072,12 +2051,12 @@ void write_sideband_v14 (nano::mdb_store & store_a, nano::transaction & transact } MDB_val val{ data.size (), data.data () }; - ASSERT_FALSE (mdb_put (store_a.env.tx (transaction_a), block->sideband ().details.epoch == nano::epoch::epoch_0 ? store_a.state_blocks_v0 : store_a.state_blocks_v1, nano::mdb_val (block_a.hash ()), &val, 0)); + ASSERT_FALSE (mdb_put (store_a.env.tx (transaction_a), block->sideband ().details.epoch == nano::epoch::epoch_0 ? store_a.state_blocks_v0_handle : store_a.state_blocks_v1_handle, nano::mdb_val (block_a.hash ()), &val, 0)); } void write_sideband_v15 (nano::mdb_store & store_a, nano::transaction & transaction_a, nano::block const & block_a) { - auto block = store_a.block_get (transaction_a, block_a.hash ()); + auto block = store_a.block.get (transaction_a, block_a.hash ()); ASSERT_NE (block, nullptr); ASSERT_LE (block->sideband ().details.epoch, nano::epoch::max); @@ -2091,12 +2070,12 @@ void write_sideband_v15 (nano::mdb_store & store_a, nano::transaction & transact } MDB_val val{ data.size (), data.data () }; - ASSERT_FALSE (mdb_put (store_a.env.tx (transaction_a), store_a.state_blocks, nano::mdb_val (block_a.hash ()), &val, 0)); + ASSERT_FALSE (mdb_put (store_a.env.tx (transaction_a), store_a.state_blocks_handle, nano::mdb_val (block_a.hash ()), &val, 0)); } void write_block_w_sideband_v18 (nano::mdb_store & store_a, MDB_dbi database, nano::write_transaction & transaction_a, nano::block const & block_a) { - auto block = store_a.block_get (transaction_a, block_a.hash ()); + auto block = store_a.block.get (transaction_a, block_a.hash ()); ASSERT_NE (block, nullptr); auto new_sideband (block->sideband ()); nano::block_sideband_v18 sideband_v18 (new_sideband.account, new_sideband.successor, new_sideband.balance, new_sideband.height, new_sideband.timestamp, new_sideband.details.epoch, new_sideband.details.is_send, new_sideband.details.is_receive, new_sideband.details.is_epoch); @@ -2116,15 +2095,15 @@ void write_block_w_sideband_v18 (nano::mdb_store & store_a, MDB_dbi database, na void modify_account_info_to_v14 (nano::mdb_store & store, nano::transaction const & transaction, nano::account const & account, uint64_t confirmation_height, nano::block_hash const & rep_block) { nano::account_info info; - ASSERT_FALSE (store.account_get (transaction, account, info)); + ASSERT_FALSE (store.account.get (transaction, account, info)); nano::account_info_v14 account_info_v14 (info.head, rep_block, info.open_block, info.balance, info.modified, info.block_count, confirmation_height, info.epoch ()); - auto status (mdb_put (store.env.tx (transaction), info.epoch () == nano::epoch::epoch_0 ? store.accounts_v0 : store.accounts_v1, nano::mdb_val (account), nano::mdb_val (account_info_v14), 0)); + auto status (mdb_put (store.env.tx (transaction), info.epoch () == nano::epoch::epoch_0 ? store.accounts_v0_handle : store.accounts_v1_handle, nano::mdb_val (account), nano::mdb_val (account_info_v14), 0)); ASSERT_EQ (status, 0); } void modify_confirmation_height_to_v15 (nano::mdb_store & store, nano::transaction const & transaction, nano::account const & account, uint64_t confirmation_height) { - auto status (mdb_put (store.env.tx (transaction), store.confirmation_height, nano::mdb_val (account), nano::mdb_val (confirmation_height), 0)); + auto status (mdb_put (store.env.tx (transaction), store.confirmation_height_handle, nano::mdb_val (account), nano::mdb_val (confirmation_height), 0)); ASSERT_EQ (status, 0); } } diff --git a/nano/core_test/blockprocessor.cpp b/nano/core_test/blockprocessor.cpp new file mode 100644 index 0000000000..a6ddcf4c5d --- /dev/null +++ b/nano/core_test/blockprocessor.cpp @@ -0,0 +1,41 @@ +#include +#include +#include +#include +#include +#include +#include + +#include + +using namespace std::chrono_literals; + +TEST (block_processor, broadcast_block_on_arrival) +{ + nano::system system; + nano::node_config config1{ nano::get_available_port (), system.logging }; + // Deactivates elections on both nodes. + config1.active_elections_size = 0; + nano::node_config config2{ nano::get_available_port (), system.logging }; + config2.active_elections_size = 0; + nano::node_flags flags; + // Disables bootstrap listener to make sure the block won't be shared by this channel. + flags.disable_bootstrap_listener = true; + auto node1 = system.add_node (config1, flags); + auto node2 = system.add_node (config2, flags); + nano::state_block_builder builder; + auto send1 = builder.make_block () + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .build_shared (); + // Adds a block to the first node. process_active() -> (calls) block_processor.add() -> add() -> + // awakes process_block() -> process_batch() -> process_one() -> process_live() + node1->process_active (send1); + // Checks whether the block was broadcast. + ASSERT_TIMELY (5s, node2->ledger.block_or_pruned_exists (send1->hash ())); +} diff --git a/nano/core_test/bootstrap.cpp b/nano/core_test/bootstrap.cpp index a08fed749e..1f5ee61f8f 100644 --- a/nano/core_test/bootstrap.cpp +++ b/nano/core_test/bootstrap.cpp @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include @@ -11,8 +11,8 @@ using namespace std::chrono_literals; TEST (bulk_pull, no_address) { nano::system system (1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - auto req = std::make_unique (); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto req = std::make_unique (nano::dev::network_params.network); req->start = 1; req->end = 2; connection->requests.push (std::unique_ptr{}); @@ -24,13 +24,13 @@ TEST (bulk_pull, no_address) TEST (bulk_pull, genesis_to_end) { nano::system system (1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - auto req = std::make_unique (); - req->start = nano::dev_genesis_key.pub; + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto req = std::make_unique (nano::dev::network_params.network); + req->start = nano::dev::genesis_key.pub; req->end.clear (); - connection->requests.push (std::unique_ptr{}); + connection->requests.push (nullptr); auto request (std::make_shared (connection, std::move (req))); - ASSERT_EQ (system.nodes[0]->latest (nano::dev_genesis_key.pub), request->current); + ASSERT_EQ (system.nodes[0]->latest (nano::dev::genesis_key.pub), request->current); ASSERT_EQ (request->request->end, request->request->end); } @@ -38,13 +38,13 @@ TEST (bulk_pull, genesis_to_end) TEST (bulk_pull, no_end) { nano::system system (1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - auto req = std::make_unique (); - req->start = nano::dev_genesis_key.pub; + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto req = std::make_unique (nano::dev::network_params.network); + req->start = nano::dev::genesis_key.pub; req->end = 1; connection->requests.push (std::unique_ptr{}); auto request (std::make_shared (connection, std::move (req))); - ASSERT_EQ (system.nodes[0]->latest (nano::dev_genesis_key.pub), request->current); + ASSERT_EQ (system.nodes[0]->latest (nano::dev::genesis_key.pub), request->current); ASSERT_TRUE (request->request->end.is_zero ()); } @@ -52,9 +52,9 @@ TEST (bulk_pull, end_not_owned) { nano::system system (1); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, 100)); - nano::block_hash latest (system.nodes[0]->latest (nano::dev_genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 100)); + nano::block_hash latest (system.nodes[0]->latest (nano::dev::genesis_key.pub)); nano::open_block open (0, 1, 2, nano::keypair ().prv, 4, 5); open.hashables.account = key2.pub; open.hashables.representative = key2.pub; @@ -63,11 +63,10 @@ TEST (bulk_pull, end_not_owned) open.signature = nano::sign_message (key2.prv, key2.pub, open.hash ()); system.nodes[0]->work_generate_blocking (open); ASSERT_EQ (nano::process_result::progress, system.nodes[0]->process (open).code); - auto connection (std::make_shared (nullptr, system.nodes[0])); - nano::genesis genesis; - auto req = std::make_unique (); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto req = std::make_unique (nano::dev::network_params.network); req->start = key2.pub; - req->end = genesis.hash (); + req->end = nano::dev::genesis->hash (); connection->requests.push (std::unique_ptr{}); auto request (std::make_shared (connection, std::move (req))); ASSERT_EQ (request->current, request->request->end); @@ -76,11 +75,10 @@ TEST (bulk_pull, end_not_owned) TEST (bulk_pull, none) { nano::system system (1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - nano::genesis genesis; - auto req = std::make_unique (); - req->start = nano::dev_genesis_key.pub; - req->end = genesis.hash (); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto req = std::make_unique (nano::dev::network_params.network); + req->start = nano::dev::genesis_key.pub; + req->end = nano::dev::genesis->hash (); connection->requests.push (std::unique_ptr{}); auto request (std::make_shared (connection, std::move (req))); auto block (request->get_next ()); @@ -90,9 +88,9 @@ TEST (bulk_pull, none) TEST (bulk_pull, get_next_on_open) { nano::system system (1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - auto req = std::make_unique (); - req->start = nano::dev_genesis_key.pub; + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto req = std::make_unique (nano::dev::network_params.network); + req->start = nano::dev::genesis_key.pub; req->end.clear (); connection->requests.push (std::unique_ptr{}); auto request (std::make_shared (connection, std::move (req))); @@ -106,16 +104,15 @@ TEST (bulk_pull, get_next_on_open) TEST (bulk_pull, by_block) { nano::system system (1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - nano::genesis genesis; - auto req = std::make_unique (); - req->start = genesis.hash (); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto req = std::make_unique (nano::dev::network_params.network); + req->start = nano::dev::genesis->hash (); req->end.clear (); connection->requests.push (std::unique_ptr{}); auto request (std::make_shared (connection, std::move (req))); auto block (request->get_next ()); ASSERT_NE (nullptr, block); - ASSERT_EQ (block->hash (), genesis.hash ()); + ASSERT_EQ (block->hash (), nano::dev::genesis->hash ()); block = request->get_next (); ASSERT_EQ (nullptr, block); @@ -124,16 +121,15 @@ TEST (bulk_pull, by_block) TEST (bulk_pull, by_block_single) { nano::system system (1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - nano::genesis genesis; - auto req = std::make_unique (); - req->start = genesis.hash (); - req->end = genesis.hash (); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto req = std::make_unique (nano::dev::network_params.network); + req->start = nano::dev::genesis->hash (); + req->end = nano::dev::genesis->hash (); connection->requests.push (std::unique_ptr{}); auto request (std::make_shared (connection, std::move (req))); auto block (request->get_next ()); ASSERT_NE (nullptr, block); - ASSERT_EQ (block->hash (), genesis.hash ()); + ASSERT_EQ (block->hash (), nano::dev::genesis->hash ()); block = request->get_next (); ASSERT_EQ (nullptr, block); @@ -143,15 +139,14 @@ TEST (bulk_pull, count_limit) { nano::system system (1); auto node0 (system.nodes[0]); - nano::genesis genesis; - auto send1 (std::make_shared (node0->latest (nano::dev_genesis_key.pub), nano::dev_genesis_key.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (node0->latest (nano::dev_genesis_key.pub)))); + auto send1 (std::make_shared (node0->latest (nano::dev::genesis_key.pub), nano::dev::genesis_key.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (node0->latest (nano::dev::genesis_key.pub)))); ASSERT_EQ (nano::process_result::progress, node0->process (*send1).code); - auto receive1 (std::make_shared (send1->hash (), send1->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ()))); + auto receive1 (std::make_shared (send1->hash (), send1->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()))); ASSERT_EQ (nano::process_result::progress, node0->process (*receive1).code); - auto connection (std::make_shared (nullptr, node0)); - auto req = std::make_unique (); + auto connection (std::make_shared (std::make_shared (*node0, nano::socket::endpoint_type_t::server), node0)); + auto req = std::make_unique (nano::dev::network_params.network); req->start = receive1->hash (); req->set_count_present (true); req->count = 2; @@ -196,19 +191,19 @@ TEST (bootstrap_processor, process_one) nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; auto node0 = system.add_node (node_config, node_flags); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto send (system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, 100)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 100)); ASSERT_NE (nullptr, send); node_config.peering_port = nano::get_available_port (); node_flags.disable_rep_crawler = true; auto node1 (std::make_shared (system.io_ctx, nano::unique_path (), node_config, system.work, node_flags)); - nano::block_hash hash1 (node0->latest (nano::dev_genesis_key.pub)); - nano::block_hash hash2 (node1->latest (nano::dev_genesis_key.pub)); + nano::block_hash hash1 (node0->latest (nano::dev::genesis_key.pub)); + nano::block_hash hash2 (node1->latest (nano::dev::genesis_key.pub)); ASSERT_NE (hash1, hash2); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_NE (node1->latest (nano::dev_genesis_key.pub), node0->latest (nano::dev_genesis_key.pub)); - ASSERT_TIMELY (10s, node1->latest (nano::dev_genesis_key.pub) == node0->latest (nano::dev_genesis_key.pub)); + ASSERT_NE (node1->latest (nano::dev::genesis_key.pub), node0->latest (nano::dev::genesis_key.pub)); + ASSERT_TIMELY (10s, node1->latest (nano::dev::genesis_key.pub) == node0->latest (nano::dev::genesis_key.pub)); ASSERT_EQ (0, node1->active.size ()); node1->stop (); } @@ -221,12 +216,12 @@ TEST (bootstrap_processor, process_two) nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; auto node0 (system.add_node (config, node_flags)); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - nano::block_hash hash1 (node0->latest (nano::dev_genesis_key.pub)); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, 50)); - nano::block_hash hash2 (node0->latest (nano::dev_genesis_key.pub)); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, 50)); - nano::block_hash hash3 (node0->latest (nano::dev_genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + nano::block_hash hash1 (node0->latest (nano::dev::genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 50)); + nano::block_hash hash2 (node0->latest (nano::dev::genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 50)); + nano::block_hash hash3 (node0->latest (nano::dev::genesis_key.pub)); ASSERT_NE (hash1, hash2); ASSERT_NE (hash1, hash3); ASSERT_NE (hash2, hash3); @@ -234,8 +229,8 @@ TEST (bootstrap_processor, process_two) auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); ASSERT_FALSE (node1->init_error ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_NE (node1->latest (nano::dev_genesis_key.pub), node0->latest (nano::dev_genesis_key.pub)); - ASSERT_TIMELY (10s, node1->latest (nano::dev_genesis_key.pub) == node0->latest (nano::dev_genesis_key.pub)); + ASSERT_NE (node1->latest (nano::dev::genesis_key.pub), node0->latest (nano::dev::genesis_key.pub)); + ASSERT_TIMELY (10s, node1->latest (nano::dev::genesis_key.pub) == node0->latest (nano::dev::genesis_key.pub)); node1->stop (); } @@ -248,41 +243,40 @@ TEST (bootstrap_processor, process_state) nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; auto node0 (system.add_node (config, node_flags)); - nano::genesis genesis; nano::state_block_builder builder; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto block1 = builder - .account (nano::dev_genesis_key.pub) - .previous (node0->latest (nano::dev_genesis_key.pub)) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 100) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (node0->latest (nano::dev::genesis_key.pub)) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 100) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) .build_shared (); auto block2 = builder .make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (block1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount) .link (block1->hash ()) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) .build_shared (); node0->work_generate_blocking (*block1); node0->work_generate_blocking (*block2); - node0->process (*block1); - node0->process (*block2); + ASSERT_EQ (nano::process_result::progress, node0->process (*block1).code); + ASSERT_EQ (nano::process_result::progress, node0->process (*block2).code); auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work, node_flags)); - ASSERT_EQ (node0->latest (nano::dev_genesis_key.pub), block2->hash ()); - ASSERT_NE (node1->latest (nano::dev_genesis_key.pub), block2->hash ()); + ASSERT_EQ (node0->latest (nano::dev::genesis_key.pub), block2->hash ()); + ASSERT_NE (node1->latest (nano::dev::genesis_key.pub), block2->hash ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_NE (node1->latest (nano::dev_genesis_key.pub), node0->latest (nano::dev_genesis_key.pub)); - ASSERT_TIMELY (10s, node1->latest (nano::dev_genesis_key.pub) == node0->latest (nano::dev_genesis_key.pub)); + ASSERT_NE (node1->latest (nano::dev::genesis_key.pub), node0->latest (nano::dev::genesis_key.pub)); + ASSERT_TIMELY (10s, node1->latest (nano::dev::genesis_key.pub) == node0->latest (nano::dev::genesis_key.pub)); ASSERT_TIMELY (10s, node1->active.empty ()); node1->stop (); } @@ -297,15 +291,15 @@ TEST (bootstrap_processor, process_new) auto node1 (system.add_node (config, node_flags)); config.peering_port = nano::get_available_port (); auto node2 (system.add_node (config, node_flags)); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key2; system.wallet (1)->insert_adhoc (key2.prv); - auto send (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node1->config.receive_minimum.number ())); + auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node1->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); ASSERT_TIMELY (10s, !node1->balance (key2.pub).is_zero ()); auto receive (node2->block (node2->latest (key2.pub))); ASSERT_NE (nullptr, receive); - nano::uint128_t balance1 (node1->balance (nano::dev_genesis_key.pub)); + nano::uint128_t balance1 (node1->balance (nano::dev::genesis_key.pub)); nano::uint128_t balance2 (node1->balance (key2.pub)); ASSERT_TIMELY (10s, node1->block_confirmed (send->hash ()) && node1->block_confirmed (receive->hash ()) && node1->active.empty () && node2->active.empty ()); // All blocks should be propagated & confirmed @@ -313,7 +307,7 @@ TEST (bootstrap_processor, process_new) ASSERT_FALSE (node3->init_error ()); node3->bootstrap_initiator.bootstrap (node1->network.endpoint (), false); ASSERT_TIMELY (10s, node3->balance (key2.pub) == balance2); - ASSERT_EQ (balance1, node3->balance (nano::dev_genesis_key.pub)); + ASSERT_EQ (balance1, node3->balance (nano::dev::genesis_key.pub)); node3->stop (); } @@ -326,19 +320,19 @@ TEST (bootstrap_processor, pull_diamond) node_flags.disable_bootstrap_bulk_push_client = true; auto node0 (system.add_node (config, node_flags)); nano::keypair key; - auto send1 (std::make_shared (node0->latest (nano::dev_genesis_key.pub), key.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (node0->latest (nano::dev_genesis_key.pub)))); + auto send1 (std::make_shared (node0->latest (nano::dev::genesis_key.pub), key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (node0->latest (nano::dev::genesis_key.pub)))); ASSERT_EQ (nano::process_result::progress, node0->process (*send1).code); auto open (std::make_shared (send1->hash (), 1, key.pub, key.prv, key.pub, *system.work.generate (key.pub))); ASSERT_EQ (nano::process_result::progress, node0->process (*open).code); - auto send2 (std::make_shared (open->hash (), nano::dev_genesis_key.pub, std::numeric_limits::max () - 100, key.prv, key.pub, *system.work.generate (open->hash ()))); + auto send2 (std::make_shared (open->hash (), nano::dev::genesis_key.pub, std::numeric_limits::max () - 100, key.prv, key.pub, *system.work.generate (open->hash ()))); ASSERT_EQ (nano::process_result::progress, node0->process (*send2).code); - auto receive (std::make_shared (send1->hash (), send2->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ()))); + auto receive (std::make_shared (send1->hash (), send2->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()))); ASSERT_EQ (nano::process_result::progress, node0->process (*receive).code); auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); ASSERT_FALSE (node1->init_error ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_TIMELY (10s, node1->balance (nano::dev_genesis_key.pub) == 100); - ASSERT_EQ (100, node1->balance (nano::dev_genesis_key.pub)); + ASSERT_TIMELY (10s, node1->balance (nano::dev::genesis_key.pub) == 100); + ASSERT_EQ (100, node1->balance (nano::dev::genesis_key.pub)); node1->stop (); } @@ -353,19 +347,18 @@ TEST (bootstrap_processor, DISABLED_pull_requeue_network_error) auto node1 (system.add_node (config, node_flags)); config.peering_port = nano::get_available_port (); auto node2 (system.add_node (config, node_flags)); - nano::genesis genesis; nano::keypair key1; nano::state_block_builder builder; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node1->bootstrap_initiator.bootstrap (node2->network.endpoint ()); @@ -377,7 +370,7 @@ TEST (bootstrap_processor, DISABLED_pull_requeue_network_error) nano::unique_lock lock (node1->bootstrap_initiator.connections->mutex); ASSERT_FALSE (attempt->stopped); ++attempt->pulling; - node1->bootstrap_initiator.connections->pulls.emplace_back (nano::dev_genesis_key.pub, send1->hash (), genesis.hash (), attempt->incremental_id); + node1->bootstrap_initiator.connections->pulls.emplace_back (nano::dev::genesis_key.pub, send1->hash (), nano::dev::genesis->hash (), attempt->incremental_id); node1->bootstrap_initiator.connections->request_pull (lock); node2->stop (); } @@ -385,7 +378,11 @@ TEST (bootstrap_processor, DISABLED_pull_requeue_network_error) ASSERT_EQ (0, node1->stats.count (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_failed_account, nano::stat::dir::in)); // Requeue is not increasing failed attempts } -TEST (bootstrap_processor, push_diamond) +// Test disabled because it's failing intermittently. +// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3558 +// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3559 +// CI run in which it failed: https://github.com/nanocurrency/nano-node/runs/4280675502?check_suite_focus=true#step:6:398 +TEST (bootstrap_processor, DISABLED_push_diamond) { nano::system system; nano::node_config config (nano::get_available_port (), system.logging); @@ -395,23 +392,27 @@ TEST (bootstrap_processor, push_diamond) auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); ASSERT_FALSE (node1->init_error ()); auto wallet1 (node1->wallets.create (100)); - wallet1->insert_adhoc (nano::dev_genesis_key.prv); + wallet1->insert_adhoc (nano::dev::genesis_key.prv); wallet1->insert_adhoc (key.prv); - auto send1 (std::make_shared (node0->latest (nano::dev_genesis_key.pub), key.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (node0->latest (nano::dev_genesis_key.pub)))); + auto send1 (std::make_shared (node0->latest (nano::dev::genesis_key.pub), key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (node0->latest (nano::dev::genesis_key.pub)))); ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); auto open (std::make_shared (send1->hash (), 1, key.pub, key.prv, key.pub, *system.work.generate (key.pub))); ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); - auto send2 (std::make_shared (open->hash (), nano::dev_genesis_key.pub, std::numeric_limits::max () - 100, key.prv, key.pub, *system.work.generate (open->hash ()))); + auto send2 (std::make_shared (open->hash (), nano::dev::genesis_key.pub, std::numeric_limits::max () - 100, key.prv, key.pub, *system.work.generate (open->hash ()))); ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); - auto receive (std::make_shared (send1->hash (), send2->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ()))); + auto receive (std::make_shared (send1->hash (), send2->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()))); ASSERT_EQ (nano::process_result::progress, node1->process (*receive).code); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_TIMELY (10s, node0->balance (nano::dev_genesis_key.pub) == 100); - ASSERT_EQ (100, node0->balance (nano::dev_genesis_key.pub)); + ASSERT_TIMELY (10s, node0->balance (nano::dev::genesis_key.pub) == 100); + ASSERT_EQ (100, node0->balance (nano::dev::genesis_key.pub)); node1->stop (); } -TEST (bootstrap_processor, push_diamond_pruning) +// Check that an outgoing bootstrap request can push blocks +// Test disabled because it's failing intermittently. +// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3512 +// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3517 +TEST (bootstrap_processor, DISABLED_push_diamond_pruning) { nano::system system; nano::node_config config (nano::get_available_port (), system.logging); @@ -424,41 +425,44 @@ TEST (bootstrap_processor, push_diamond_pruning) node_flags.enable_pruning = true; auto node1 (std::make_shared (system.io_ctx, nano::unique_path (), config, system.work, node_flags, 1)); ASSERT_FALSE (node1->init_error ()); - auto latest (node0->latest (nano::dev_genesis_key.pub)); - auto send1 (std::make_shared (latest, key.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest))); + auto latest (node0->latest (nano::dev::genesis_key.pub)); + auto send1 (std::make_shared (latest, key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest))); ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); auto open (std::make_shared (send1->hash (), 1, key.pub, key.prv, key.pub, *system.work.generate (key.pub))); ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); // 1st bootstrap node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_TIMELY (10s, node0->balance (key.pub) == nano::genesis_amount); + ASSERT_TIMELY (10s, node0->balance (key.pub) == nano::dev::constants.genesis_amount); // Process more blocks & prune old - auto send2 (std::make_shared (open->hash (), nano::dev_genesis_key.pub, std::numeric_limits::max () - 100, key.prv, key.pub, *system.work.generate (open->hash ()))); + auto send2 (std::make_shared (open->hash (), nano::dev::genesis_key.pub, std::numeric_limits::max () - 100, key.prv, key.pub, *system.work.generate (open->hash ()))); ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); - auto receive (std::make_shared (send1->hash (), send2->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ()))); + auto receive (std::make_shared (send1->hash (), send2->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()))); ASSERT_EQ (nano::process_result::progress, node1->process (*receive).code); { auto transaction (node1->store.tx_begin_write ()); ASSERT_EQ (1, node1->ledger.pruning_action (transaction, send1->hash (), 2)); ASSERT_EQ (1, node1->ledger.pruning_action (transaction, open->hash (), 1)); - ASSERT_TRUE (node1->store.block_exists (transaction, latest)); - ASSERT_FALSE (node1->store.block_exists (transaction, send1->hash ())); - ASSERT_TRUE (node1->store.pruned_exists (transaction, send1->hash ())); - ASSERT_FALSE (node1->store.block_exists (transaction, open->hash ())); - ASSERT_TRUE (node1->store.pruned_exists (transaction, open->hash ())); - ASSERT_TRUE (node1->store.block_exists (transaction, send2->hash ())); - ASSERT_TRUE (node1->store.block_exists (transaction, receive->hash ())); + ASSERT_TRUE (node1->store.block.exists (transaction, latest)); + ASSERT_FALSE (node1->store.block.exists (transaction, send1->hash ())); + ASSERT_TRUE (node1->store.pruned.exists (transaction, send1->hash ())); + ASSERT_FALSE (node1->store.block.exists (transaction, open->hash ())); + ASSERT_TRUE (node1->store.pruned.exists (transaction, open->hash ())); + ASSERT_TRUE (node1->store.block.exists (transaction, send2->hash ())); + ASSERT_TRUE (node1->store.block.exists (transaction, receive->hash ())); ASSERT_EQ (2, node1->ledger.cache.pruned_count); ASSERT_EQ (5, node1->ledger.cache.block_count); } // 2nd bootstrap node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_TIMELY (10s, node0->balance (nano::dev_genesis_key.pub) == 100); - ASSERT_EQ (100, node0->balance (nano::dev_genesis_key.pub)); + ASSERT_TIMELY (10s, node0->balance (nano::dev::genesis_key.pub) == 100); + ASSERT_EQ (100, node0->balance (nano::dev::genesis_key.pub)); node1->stop (); } -TEST (bootstrap_processor, push_one) +// Test disabled because it's failing intermittently. +// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3532 +// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3533 +TEST (bootstrap_processor, DISABLED_push_one) { nano::system system; nano::node_config config (nano::get_available_port (), system.logging); @@ -468,13 +472,13 @@ TEST (bootstrap_processor, push_one) auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); auto wallet (node1->wallets.create (nano::random_wallet_id ())); ASSERT_NE (nullptr, wallet); - wallet->insert_adhoc (nano::dev_genesis_key.prv); - nano::uint128_t balance1 (node1->balance (nano::dev_genesis_key.pub)); - auto send (wallet->send_action (nano::dev_genesis_key.pub, key1.pub, 100)); + wallet->insert_adhoc (nano::dev::genesis_key.prv); + nano::uint128_t balance1 (node1->balance (nano::dev::genesis_key.pub)); + auto send (wallet->send_action (nano::dev::genesis_key.pub, key1.pub, 100)); ASSERT_NE (nullptr, send); - ASSERT_NE (balance1, node1->balance (nano::dev_genesis_key.pub)); + ASSERT_NE (balance1, node1->balance (nano::dev::genesis_key.pub)); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); - ASSERT_TIMELY (10s, node0->balance (nano::dev_genesis_key.pub) != balance1); + ASSERT_TIMELY (10s, node0->balance (nano::dev::genesis_key.pub) != balance1); node1->stop (); } @@ -486,7 +490,6 @@ TEST (bootstrap_processor, lazy_hash) nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; auto node0 (system.add_node (config, node_flags)); - nano::genesis genesis; nano::keypair key1; nano::keypair key2; // Generating test chain @@ -494,13 +497,13 @@ TEST (bootstrap_processor, lazy_hash) nano::state_block_builder builder; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node0->work_generate_blocking (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); auto receive1 = builder .make_block () @@ -541,7 +544,7 @@ TEST (bootstrap_processor, lazy_hash) node0->block_processor.flush (); // Start lazy bootstrap with last block in chain known auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); - node1->network.udp_channels.insert (node0->network.endpoint (), node1->network_params.protocol.protocol_version); + node1->network.udp_channels.insert (node0->network.endpoint (), node1->network_params.network.protocol_version); node1->bootstrap_initiator.bootstrap_lazy (receive2->hash (), true); { auto lazy_attempt (node1->bootstrap_initiator.current_lazy_attempt ()); @@ -561,7 +564,6 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id) nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; auto node0 (system.add_node (config, node_flags)); - nano::genesis genesis; nano::keypair key1; nano::keypair key2; // Generating test chain @@ -569,13 +571,13 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id) nano::state_block_builder builder; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node0->work_generate_blocking (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); auto receive1 = builder .make_block () @@ -616,7 +618,7 @@ TEST (bootstrap_processor, lazy_hash_bootstrap_id) node0->block_processor.flush (); // Start lazy bootstrap with last block in chain known auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); - node1->network.udp_channels.insert (node0->network.endpoint (), node1->network_params.protocol.protocol_version); + node1->network.udp_channels.insert (node0->network.endpoint (), node1->network_params.network.protocol_version); node1->bootstrap_initiator.bootstrap_lazy (receive2->hash (), true, true, "123456"); { auto lazy_attempt (node1->bootstrap_initiator.current_lazy_attempt ()); @@ -638,7 +640,6 @@ TEST (bootstrap_processor, lazy_hash_pruning) node_flags.disable_bootstrap_bulk_push_client = true; node_flags.enable_pruning = true; auto node0 (system.add_node (config, node_flags)); - nano::genesis genesis; nano::keypair key1; nano::keypair key2; // Generating test chain @@ -646,52 +647,52 @@ TEST (bootstrap_processor, lazy_hash_pruning) nano::state_block_builder builder; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node0->work_generate_blocking (genesis.hash ())) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); auto receive1 = builder .make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount) .link (send1->hash ()) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (send1->hash ())) .build_shared (); auto change1 = builder .make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (receive1->hash ()) .representative (key1.pub) - .balance (nano::genesis_amount) + .balance (nano::dev::constants.genesis_amount) .link (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (receive1->hash ())) .build_shared (); auto change2 = builder .make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (change1->hash ()) .representative (key2.pub) - .balance (nano::genesis_amount) + .balance (nano::dev::constants.genesis_amount) .link (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (change1->hash ())) .build_shared (); auto send2 = builder .make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (change2->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node0->work_generate_blocking (change2->hash ())) .build_shared (); auto receive2 = builder @@ -755,7 +756,7 @@ TEST (bootstrap_processor, lazy_hash_pruning) ASSERT_EQ (5, node1->ledger.cache.block_count); ASSERT_EQ (3, node1->ledger.cache.pruned_count); // Start lazy bootstrap with last block in chain known - node1->network.udp_channels.insert (node0->network.endpoint (), node1->network_params.protocol.protocol_version); + node1->network.udp_channels.insert (node0->network.endpoint (), node1->network_params.network.protocol_version); node1->bootstrap_initiator.bootstrap_lazy (receive3->hash (), true); // Check processed blocks ASSERT_TIMELY (10s, node1->ledger.cache.block_count == 9); @@ -772,7 +773,6 @@ TEST (bootstrap_processor, lazy_max_pull_count) nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; auto node0 (system.add_node (config, node_flags)); - nano::genesis genesis; nano::keypair key1; nano::keypair key2; // Generating test chain @@ -780,13 +780,13 @@ TEST (bootstrap_processor, lazy_max_pull_count) nano::state_block_builder builder; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node0->work_generate_blocking (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); auto receive1 = builder .make_block () @@ -832,7 +832,7 @@ TEST (bootstrap_processor, lazy_max_pull_count) .make_block () .account (key2.pub) .previous (change1->hash ()) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (nano::MBAN_ratio) .link (0) .sign (key2.prv, key2.pub) @@ -859,7 +859,7 @@ TEST (bootstrap_processor, lazy_max_pull_count) node0->block_processor.flush (); // Start lazy bootstrap with last block in chain known auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); - node1->network.udp_channels.insert (node0->network.endpoint (), node1->network_params.protocol.protocol_version); + node1->network.udp_channels.insert (node0->network.endpoint (), node1->network_params.network.protocol_version); node1->bootstrap_initiator.bootstrap_lazy (change3->hash ()); // Check processed blocks ASSERT_TIMELY (10s, node1->block (change3->hash ())); @@ -876,30 +876,29 @@ TEST (bootstrap_processor, lazy_unclear_state_link) node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_legacy_bootstrap = true; auto node1 = system.add_node (config, node_flags); - nano::genesis genesis; nano::keypair key; // Generating test chain nano::state_block_builder builder; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); auto send2 = builder .make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); @@ -918,7 +917,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link) ASSERT_EQ (nano::process_result::progress, node1->process (*receive).code); // Start lazy bootstrap with last block in chain known auto node2 = system.add_node (nano::node_config (nano::get_available_port (), system.logging), node_flags); - node2->network.udp_channels.insert (node1->network.endpoint (), node1->network_params.protocol.protocol_version); + node2->network.udp_channels.insert (node1->network.endpoint (), node1->network_params.network.protocol_version); node2->bootstrap_initiator.bootstrap_lazy (receive->hash ()); // Check processed blocks ASSERT_TIMELY (10s, !node2->bootstrap_initiator.in_progress ()); @@ -939,20 +938,19 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_legacy_bootstrap = true; auto node1 = system.add_node (config, node_flags); - nano::genesis genesis; nano::keypair key, key2; // Generating test chain nano::state_block_builder builder; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); auto open (std::make_shared (send1->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub))); @@ -971,7 +969,7 @@ TEST (bootstrap_processor, lazy_unclear_state_link_not_existing) // Start lazy bootstrap with last block in chain known auto node2 = system.add_node (nano::node_config (nano::get_available_port (), system.logging), node_flags); - node2->network.udp_channels.insert (node1->network.endpoint (), node1->network_params.protocol.protocol_version); + node2->network.udp_channels.insert (node1->network.endpoint (), node1->network_params.network.protocol_version); node2->bootstrap_initiator.bootstrap_lazy (send2->hash ()); // Check processed blocks ASSERT_TIMELY (15s, !node2->bootstrap_initiator.in_progress ()); @@ -991,30 +989,29 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations) node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_legacy_bootstrap = true; auto node1 = system.add_node (config, node_flags); - nano::genesis genesis; nano::keypair key1, key2; // Generating test chain nano::state_block_builder builder; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); auto send2 = builder .make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) .link (key2.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process (*send2).code); @@ -1034,7 +1031,7 @@ TEST (bootstrap_processor, DISABLED_lazy_destinations) // Start lazy bootstrap with last block in sender chain auto node2 = system.add_node (nano::node_config (nano::get_available_port (), system.logging), node_flags); - node2->network.udp_channels.insert (node1->network.endpoint (), node1->network_params.protocol.protocol_version); + node2->network.udp_channels.insert (node1->network.endpoint (), node1->network_params.network.protocol_version); node2->bootstrap_initiator.bootstrap_lazy (send2->hash ()); // Check processed blocks ASSERT_TIMELY (10s, !node2->bootstrap_initiator.in_progress ()); @@ -1056,30 +1053,29 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) node_flags.disable_legacy_bootstrap = true; node_flags.enable_pruning = true; auto node1 = system.add_node (config, node_flags); - nano::genesis genesis; nano::keypair key1, key2; // Generating test chain nano::state_block_builder builder; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node1->process_active (send1); auto send2 = builder .make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) .link (key2.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); node1->process_active (send2); @@ -1113,7 +1109,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) // Start lazy bootstrap with last block in sender chain config.peering_port = nano::get_available_port (); auto node2 (std::make_shared (system.io_ctx, nano::unique_path (), config, system.work, node_flags, 1)); - node2->network.udp_channels.insert (node1->network.endpoint (), node1->network_params.protocol.protocol_version); + node2->network.udp_channels.insert (node1->network.endpoint (), node1->network_params.network.protocol_version); node2->bootstrap_initiator.bootstrap_lazy (send2->hash ()); // Check processed blocks auto lazy_attempt (node2->bootstrap_initiator.current_lazy_attempt ()); @@ -1128,7 +1124,7 @@ TEST (bootstrap_processor, lazy_pruning_missing_block) ASSERT_FALSE (node2->ledger.block_or_pruned_exists (state_open->hash ())); { auto transaction (node2->store.tx_begin_read ()); - ASSERT_TRUE (node2->store.unchecked_exists (transaction, nano::unchecked_key (send2->root ().as_block_hash (), send2->hash ()))); + ASSERT_TRUE (node2->store.unchecked.exists (transaction, nano::unchecked_key (send2->root ().as_block_hash (), send2->hash ()))); } // Insert missing block node2->process_active (send1); @@ -1151,25 +1147,24 @@ TEST (bootstrap_processor, lazy_cancel) nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; auto node0 (system.add_node (config, node_flags)); - nano::genesis genesis; nano::keypair key1; // Generating test chain nano::state_block_builder builder; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node0->work_generate_blocking (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); // Start lazy bootstrap with last block in chain known auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); - node1->network.udp_channels.insert (node0->network.endpoint (), node1->network_params.protocol.protocol_version); + node1->network.udp_channels.insert (node0->network.endpoint (), node1->network_params.network.protocol_version); node1->bootstrap_initiator.bootstrap_lazy (send1->hash (), true); // Start "confirmed" block bootstrap { auto lazy_attempt (node1->bootstrap_initiator.current_lazy_attempt ()); @@ -1190,7 +1185,6 @@ TEST (bootstrap_processor, wallet_lazy_frontier) node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_legacy_bootstrap = true; auto node0 = system.add_node (config, node_flags); - nano::genesis genesis; nano::keypair key1; nano::keypair key2; // Generating test chain @@ -1198,13 +1192,13 @@ TEST (bootstrap_processor, wallet_lazy_frontier) nano::state_block_builder builder; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node0->work_generate_blocking (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); auto receive1 = builder .make_block () @@ -1245,7 +1239,7 @@ TEST (bootstrap_processor, wallet_lazy_frontier) node0->block_processor.flush (); // Start wallet lazy bootstrap auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); - node1->network.udp_channels.insert (node0->network.endpoint (), node1->network_params.protocol.protocol_version); + node1->network.udp_channels.insert (node0->network.endpoint (), node1->network_params.network.protocol_version); auto wallet (node1->wallets.create (nano::random_wallet_id ())); ASSERT_NE (nullptr, wallet); wallet->insert_adhoc (key2.prv); @@ -1269,7 +1263,6 @@ TEST (bootstrap_processor, wallet_lazy_pending) node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_legacy_bootstrap = true; auto node0 = system.add_node (config, node_flags); - nano::genesis genesis; nano::keypair key1; nano::keypair key2; // Generating test chain @@ -1277,13 +1270,13 @@ TEST (bootstrap_processor, wallet_lazy_pending) nano::state_block_builder builder; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node0->work_generate_blocking (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); auto receive1 = builder .make_block () @@ -1313,7 +1306,7 @@ TEST (bootstrap_processor, wallet_lazy_pending) node0->block_processor.flush (); // Start wallet lazy bootstrap auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); - node1->network.udp_channels.insert (node0->network.endpoint (), node1->network_params.protocol.protocol_version); + node1->network.udp_channels.insert (node0->network.endpoint (), node1->network_params.network.protocol_version); auto wallet (node1->wallets.create (nano::random_wallet_id ())); ASSERT_NE (nullptr, wallet); wallet->insert_adhoc (key2.prv); @@ -1331,7 +1324,6 @@ TEST (bootstrap_processor, multiple_attempts) nano::node_flags node_flags; node_flags.disable_bootstrap_bulk_push_client = true; auto node1 = system.add_node (config, node_flags); - nano::genesis genesis; nano::keypair key1; nano::keypair key2; // Generating test chain @@ -1339,13 +1331,13 @@ TEST (bootstrap_processor, multiple_attempts) nano::state_block_builder builder; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node1->work_generate_blocking (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); auto receive1 = builder .make_block () @@ -1388,7 +1380,7 @@ TEST (bootstrap_processor, multiple_attempts) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.bootstrap_initiator_threads = 3; auto node2 (std::make_shared (system.io_ctx, nano::unique_path (), node_config, system.work)); - node2->network.udp_channels.insert (node1->network.endpoint (), node2->network_params.protocol.protocol_version); + node2->network.udp_channels.insert (node1->network.endpoint (), node2->network_params.network.protocol_version); node2->bootstrap_initiator.bootstrap_lazy (receive2->hash (), true); node2->bootstrap_initiator.bootstrap (); auto lazy_attempt (node2->bootstrap_initiator.current_lazy_attempt ()); @@ -1412,7 +1404,7 @@ TEST (frontier_req_response, DISABLED_destruction) { nano::system system (1); auto connection (std::make_shared (nullptr, system.nodes[0])); - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = std::numeric_limitsage)>::max (); req->count = std::numeric_limitscount)>::max (); @@ -1426,24 +1418,23 @@ TEST (frontier_req_response, DISABLED_destruction) TEST (frontier_req, begin) { nano::system system (1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - auto req = std::make_unique (); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = std::numeric_limitsage)>::max (); req->count = std::numeric_limitscount)>::max (); connection->requests.push (std::unique_ptr{}); auto request (std::make_shared (connection, std::move (req))); - ASSERT_EQ (nano::dev_genesis_key.pub, request->current); - nano::genesis genesis; - ASSERT_EQ (genesis.hash (), request->frontier); + ASSERT_EQ (nano::dev::genesis_key.pub, request->current); + ASSERT_EQ (nano::dev::genesis->hash (), request->frontier); } TEST (frontier_req, end) { nano::system system (1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - auto req = std::make_unique (); - req->start = nano::dev_genesis_key.pub.number () + 1; + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto req = std::make_unique (nano::dev::network_params.network); + req->start = nano::dev::genesis_key.pub.number () + 1; req->age = std::numeric_limitsage)>::max (); req->count = std::numeric_limitscount)>::max (); connection->requests.push (std::unique_ptr{}); @@ -1455,18 +1446,17 @@ TEST (frontier_req, count) { nano::system system (1); auto node1 = system.nodes[0]; - nano::genesis genesis; // Public key FB93... after genesis in accounts table nano::keypair key1 ("ED5AE0A6505B14B67435C29FD9FEEBC26F597D147BC92F6D795FFAD7AFD3D967"); nano::state_block_builder builder; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) .build_shared (); node1->work_generate_blocking (*send1); @@ -1475,7 +1465,7 @@ TEST (frontier_req, count) .make_block () .account (key1.pub) .previous (0) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (nano::MBAN_ratio) .link (send1->hash ()) .sign (key1.prv, key1.pub) @@ -1484,35 +1474,35 @@ TEST (frontier_req, count) node1->work_generate_blocking (*receive1); ASSERT_EQ (nano::process_result::progress, node1->process (*receive1).code); - auto connection (std::make_shared (nullptr, node1)); - auto req = std::make_unique (); + auto connection (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = std::numeric_limitsage)>::max (); req->count = 1; connection->requests.push (std::unique_ptr{}); auto request (std::make_shared (connection, std::move (req))); - ASSERT_EQ (nano::dev_genesis_key.pub, request->current); + ASSERT_EQ (nano::dev::genesis_key.pub, request->current); ASSERT_EQ (send1->hash (), request->frontier); } TEST (frontier_req, time_bound) { nano::system system (1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - auto req = std::make_unique (); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = 1; req->count = std::numeric_limitscount)>::max (); connection->requests.push (std::unique_ptr{}); auto request (std::make_shared (connection, std::move (req))); - ASSERT_EQ (nano::dev_genesis_key.pub, request->current); + ASSERT_EQ (nano::dev::genesis_key.pub, request->current); // Wait 2 seconds until age of account will be > 1 seconds std::this_thread::sleep_for (std::chrono::milliseconds (2100)); - auto req2 (std::make_unique ()); + auto req2 (std::make_unique (nano::dev::network_params.network)); req2->start.clear (); req2->age = 1; req2->count = std::numeric_limitscount)>::max (); - auto connection2 (std::make_shared (nullptr, system.nodes[0])); + auto connection2 (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); connection2->requests.push (std::unique_ptr{}); auto request2 (std::make_shared (connection, std::move (req2))); ASSERT_TRUE (request2->current.is_zero ()); @@ -1521,23 +1511,22 @@ TEST (frontier_req, time_bound) TEST (frontier_req, time_cutoff) { nano::system system (1); - auto connection (std::make_shared (nullptr, system.nodes[0])); - auto req = std::make_unique (); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); + auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = 3; req->count = std::numeric_limitscount)>::max (); connection->requests.push (std::unique_ptr{}); auto request (std::make_shared (connection, std::move (req))); - ASSERT_EQ (nano::dev_genesis_key.pub, request->current); - nano::genesis genesis; - ASSERT_EQ (genesis.hash (), request->frontier); + ASSERT_EQ (nano::dev::genesis_key.pub, request->current); + ASSERT_EQ (nano::dev::genesis->hash (), request->frontier); // Wait 4 seconds until age of account will be > 3 seconds std::this_thread::sleep_for (std::chrono::milliseconds (4100)); - auto req2 (std::make_unique ()); + auto req2 (std::make_unique (nano::dev::network_params.network)); req2->start.clear (); req2->age = 3; req2->count = std::numeric_limitscount)>::max (); - auto connection2 (std::make_shared (nullptr, system.nodes[0])); + auto connection2 (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); connection2->requests.push (std::unique_ptr{}); auto request2 (std::make_shared (connection, std::move (req2))); ASSERT_TRUE (request2->frontier.is_zero ()); @@ -1547,41 +1536,39 @@ TEST (frontier_req, confirmed_frontier) { nano::system system (1); auto node1 = system.nodes[0]; - nano::genesis genesis; - nano::raw_key priv_key; + nano::keypair key_before_genesis; // Public key before genesis in accounts table - while (nano::pub_key (priv_key).number () >= nano::dev_genesis_key.pub.number ()) + while (key_before_genesis.pub.number () >= nano::dev::genesis_key.pub.number ()) { - priv_key = nano::keypair ().prv; + key_before_genesis = nano::keypair (); } - nano::keypair key_before_genesis (priv_key.to_string ()); + nano::keypair key_after_genesis; // Public key after genesis in accounts table - while (nano::pub_key (priv_key).number () <= nano::dev_genesis_key.pub.number ()) + while (key_after_genesis.pub.number () <= nano::dev::genesis_key.pub.number ()) { - priv_key = nano::keypair ().prv; + key_after_genesis = nano::keypair (); } - nano::keypair key_after_genesis (priv_key.to_string ()); nano::state_block_builder builder; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key_before_genesis.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) .build_shared (); node1->work_generate_blocking (*send1); ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); auto send2 = builder .make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) .link (key_after_genesis.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) .build_shared (); node1->work_generate_blocking (*send2); @@ -1590,7 +1577,7 @@ TEST (frontier_req, confirmed_frontier) .make_block () .account (key_before_genesis.pub) .previous (0) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (nano::MBAN_ratio) .link (send1->hash ()) .sign (key_before_genesis.prv, key_before_genesis.pub) @@ -1602,7 +1589,7 @@ TEST (frontier_req, confirmed_frontier) .make_block () .account (key_after_genesis.pub) .previous (0) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (nano::MBAN_ratio) .link (send2->hash ()) .sign (key_after_genesis.prv, key_after_genesis.pub) @@ -1612,8 +1599,8 @@ TEST (frontier_req, confirmed_frontier) ASSERT_EQ (nano::process_result::progress, node1->process (*receive2).code); // Request for all accounts (confirmed only) - auto connection (std::make_shared (nullptr, node1)); - auto req = std::make_unique (); + auto connection (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto req = std::make_unique (nano::dev::network_params.network); req->start.clear (); req->age = std::numeric_limitsage)>::max (); req->count = std::numeric_limitscount)>::max (); @@ -1622,12 +1609,12 @@ TEST (frontier_req, confirmed_frontier) ASSERT_TRUE (req->header.frontier_req_is_only_confirmed_present ()); connection->requests.push (std::unique_ptr{}); auto request (std::make_shared (connection, std::move (req))); - ASSERT_EQ (nano::dev_genesis_key.pub, request->current); - ASSERT_EQ (genesis.hash (), request->frontier); + ASSERT_EQ (nano::dev::genesis_key.pub, request->current); + ASSERT_EQ (nano::dev::genesis->hash (), request->frontier); // Request starting with account before genesis (confirmed only) - auto connection2 (std::make_shared (nullptr, node1)); - auto req2 = std::make_unique (); + auto connection2 (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto req2 = std::make_unique (nano::dev::network_params.network); req2->start = key_before_genesis.pub; req2->age = std::numeric_limitsage)>::max (); req2->count = std::numeric_limitscount)>::max (); @@ -1636,12 +1623,12 @@ TEST (frontier_req, confirmed_frontier) ASSERT_TRUE (req2->header.frontier_req_is_only_confirmed_present ()); connection2->requests.push (std::unique_ptr{}); auto request2 (std::make_shared (connection2, std::move (req2))); - ASSERT_EQ (nano::dev_genesis_key.pub, request2->current); - ASSERT_EQ (genesis.hash (), request2->frontier); + ASSERT_EQ (nano::dev::genesis_key.pub, request2->current); + ASSERT_EQ (nano::dev::genesis->hash (), request2->frontier); // Request starting with account after genesis (confirmed only) - auto connection3 (std::make_shared (nullptr, node1)); - auto req3 = std::make_unique (); + auto connection3 (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto req3 = std::make_unique (nano::dev::network_params.network); req3->start = key_after_genesis.pub; req3->age = std::numeric_limitsage)>::max (); req3->count = std::numeric_limitscount)>::max (); @@ -1654,8 +1641,8 @@ TEST (frontier_req, confirmed_frontier) ASSERT_TRUE (request3->frontier.is_zero ()); // Request for all accounts (unconfirmed blocks) - auto connection4 (std::make_shared (nullptr, node1)); - auto req4 = std::make_unique (); + auto connection4 (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto req4 = std::make_unique (nano::dev::network_params.network); req4->start.clear (); req4->age = std::numeric_limitsage)>::max (); req4->count = std::numeric_limitscount)>::max (); @@ -1666,8 +1653,8 @@ TEST (frontier_req, confirmed_frontier) ASSERT_EQ (receive1->hash (), request4->frontier); // Request starting with account after genesis (unconfirmed blocks) - auto connection5 (std::make_shared (nullptr, node1)); - auto req5 = std::make_unique (); + auto connection5 (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto req5 = std::make_unique (nano::dev::network_params.network); req5->start = key_after_genesis.pub; req5->age = std::numeric_limitsage)>::max (); req5->count = std::numeric_limitscount)>::max (); @@ -1680,8 +1667,8 @@ TEST (frontier_req, confirmed_frontier) // Confirm account before genesis (confirmed only) nano::blocks_confirm (*node1, { send1, receive1 }, true); ASSERT_TIMELY (5s, node1->block_confirmed (send1->hash ()) && node1->block_confirmed (receive1->hash ())); - auto connection6 (std::make_shared (nullptr, node1)); - auto req6 = std::make_unique (); + auto connection6 (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto req6 = std::make_unique (nano::dev::network_params.network); req6->start = key_before_genesis.pub; req6->age = std::numeric_limitsage)>::max (); req6->count = std::numeric_limitscount)>::max (); @@ -1696,8 +1683,8 @@ TEST (frontier_req, confirmed_frontier) // Confirm account after genesis (confirmed only) nano::blocks_confirm (*node1, { send2, receive2 }, true); ASSERT_TIMELY (5s, node1->block_confirmed (send2->hash ()) && node1->block_confirmed (receive2->hash ())); - auto connection7 (std::make_shared (nullptr, node1)); - auto req7 = std::make_unique (); + auto connection7 (std::make_shared (std::make_shared (*node1, nano::socket::endpoint_type_t::server), node1)); + auto req7 = std::make_unique (nano::dev::network_params.network); req7->start = key_after_genesis.pub; req7->age = std::numeric_limitsage)>::max (); req7->count = std::numeric_limitscount)>::max (); @@ -1719,21 +1706,21 @@ TEST (bulk, genesis) node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_lazy_bootstrap = true; auto node1 = system.add_node (config, node_flags); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto node2 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); ASSERT_FALSE (node2->init_error ()); - nano::block_hash latest1 (node1->latest (nano::dev_genesis_key.pub)); - nano::block_hash latest2 (node2->latest (nano::dev_genesis_key.pub)); + nano::block_hash latest1 (node1->latest (nano::dev::genesis_key.pub)); + nano::block_hash latest2 (node2->latest (nano::dev::genesis_key.pub)); ASSERT_EQ (latest1, latest2); nano::keypair key2; - auto send (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, 100)); + auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 100)); ASSERT_NE (nullptr, send); - nano::block_hash latest3 (node1->latest (nano::dev_genesis_key.pub)); + nano::block_hash latest3 (node1->latest (nano::dev::genesis_key.pub)); ASSERT_NE (latest1, latest3); node2->bootstrap_initiator.bootstrap (node1->network.endpoint (), false); - ASSERT_TIMELY (10s, node2->latest (nano::dev_genesis_key.pub) == node1->latest (nano::dev_genesis_key.pub)); - ASSERT_EQ (node2->latest (nano::dev_genesis_key.pub), node1->latest (nano::dev_genesis_key.pub)); + ASSERT_TIMELY (10s, node2->latest (nano::dev::genesis_key.pub) == node1->latest (nano::dev::genesis_key.pub)); + ASSERT_EQ (node2->latest (nano::dev::genesis_key.pub), node1->latest (nano::dev::genesis_key.pub)); node2->stop (); } @@ -1746,7 +1733,7 @@ TEST (bulk, offline_send) node_flags.disable_bootstrap_bulk_push_client = true; node_flags.disable_lazy_bootstrap = true; auto node1 = system.add_node (config, node_flags); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto node2 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); ASSERT_FALSE (node2->init_error ()); node2->start (); @@ -1754,14 +1741,14 @@ TEST (bulk, offline_send) nano::keypair key2; auto wallet (node2->wallets.create (nano::random_wallet_id ())); wallet->insert_adhoc (key2.prv); - auto send1 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node1->config.receive_minimum.number ())); + auto send1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node1->config.receive_minimum.number ())); ASSERT_NE (nullptr, send1); - ASSERT_NE (std::numeric_limits::max (), node1->balance (nano::dev_genesis_key.pub)); + ASSERT_NE (std::numeric_limits::max (), node1->balance (nano::dev::genesis_key.pub)); node1->block_processor.flush (); node1->scheduler.flush (); // Wait to finish election background tasks ASSERT_TIMELY (10s, node1->active.empty ()); - ASSERT_TRUE (node1->block_confirmed (send1->hash ())); + ASSERT_TIMELY (10s, node1->block_confirmed (send1->hash ())); // Initiate bootstrap node2->bootstrap_initiator.bootstrap (node1->network.endpoint ()); // Nodes should find each other @@ -1771,7 +1758,7 @@ TEST (bulk, offline_send) ASSERT_NO_ERROR (system.poll ()); } while (node1->network.empty () || node2->network.empty ()); // Send block arrival via bootstrap - ASSERT_TIMELY (10s, node2->balance (nano::dev_genesis_key.pub) != std::numeric_limits::max ()); + ASSERT_TIMELY (10s, node2->balance (nano::dev::genesis_key.pub) != std::numeric_limits::max ()); // Receiving send block ASSERT_TIMELY (20s, node2->balance (key2.pub) == node1->config.receive_minimum.number ()); node2->stop (); @@ -1789,25 +1776,25 @@ TEST (bulk, genesis_pruning) node_flags.disable_ongoing_bootstrap = true; node_flags.enable_pruning = true; auto node1 = system.add_node (config, node_flags); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); node_flags.enable_pruning = false; auto node2 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work, node_flags)); ASSERT_FALSE (node2->init_error ()); - nano::block_hash latest1 (node1->latest (nano::dev_genesis_key.pub)); - nano::block_hash latest2 (node2->latest (nano::dev_genesis_key.pub)); + nano::block_hash latest1 (node1->latest (nano::dev::genesis_key.pub)); + nano::block_hash latest2 (node2->latest (nano::dev::genesis_key.pub)); ASSERT_EQ (latest1, latest2); nano::keypair key2; - auto send1 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, 100)); + auto send1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 100)); ASSERT_NE (nullptr, send1); - auto send2 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, 100)); + auto send2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 100)); ASSERT_NE (nullptr, send2); - auto send3 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, 100)); + auto send3 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 100)); ASSERT_NE (nullptr, send3); { auto transaction (node1->wallets.tx_begin_write ()); - system.wallet (0)->store.erase (transaction, nano::dev_genesis_key.pub); + system.wallet (0)->store.erase (transaction, nano::dev::genesis_key.pub); } - nano::block_hash latest3 (node1->latest (nano::dev_genesis_key.pub)); + nano::block_hash latest3 (node1->latest (nano::dev::genesis_key.pub)); ASSERT_NE (latest1, latest3); ASSERT_EQ (send3->hash (), latest3); // Confirm last block to prune previous @@ -1845,7 +1832,7 @@ TEST (bulk, genesis_pruning) ASSERT_EQ (1, node2->ledger.cache.block_count); { auto transaction (node2->store.tx_begin_write ()); - node2->store.unchecked_clear (transaction); + node2->store.unchecked.clear (transaction); } // Insert pruned blocks node2->process_active (send1); @@ -1855,8 +1842,8 @@ TEST (bulk, genesis_pruning) // New bootstrap ASSERT_TIMELY (5s, node2->bootstrap_initiator.connections->connections_count == 0); node2->bootstrap_initiator.bootstrap (node1->network.endpoint (), false); - ASSERT_TIMELY (10s, node2->latest (nano::dev_genesis_key.pub) == node1->latest (nano::dev_genesis_key.pub)); - ASSERT_EQ (node2->latest (nano::dev_genesis_key.pub), node1->latest (nano::dev_genesis_key.pub)); + ASSERT_TIMELY (10s, node2->latest (nano::dev::genesis_key.pub) == node1->latest (nano::dev::genesis_key.pub)); + ASSERT_EQ (node2->latest (nano::dev::genesis_key.pub), node1->latest (nano::dev::genesis_key.pub)); node2->stop (); } @@ -1865,16 +1852,16 @@ TEST (bulk_pull_account, basics) nano::system system (1); system.nodes[0]->config.receive_minimum = 20; nano::keypair key1; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key1.prv); - auto send1 (system.wallet (0)->send_action (nano::genesis_account, key1.pub, 25)); - auto send2 (system.wallet (0)->send_action (nano::genesis_account, key1.pub, 10)); - auto send3 (system.wallet (0)->send_action (nano::genesis_account, key1.pub, 2)); + auto send1 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 25)); + auto send2 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 10)); + auto send3 (system.wallet (0)->send_action (nano::dev::genesis->account (), key1.pub, 2)); ASSERT_TIMELY (5s, system.nodes[0]->balance (key1.pub) == 25); - auto connection (std::make_shared (nullptr, system.nodes[0])); + auto connection (std::make_shared (std::make_shared (*system.nodes[0], nano::socket::endpoint_type_t::server), system.nodes[0])); { - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->account = key1.pub; req->minimum_amount = 5; req->flags = nano::bulk_pull_account_flags (); @@ -1888,12 +1875,12 @@ TEST (bulk_pull_account, basics) auto block_data (request->get_next ()); ASSERT_EQ (send2->hash (), block_data.first.get ()->hash); ASSERT_EQ (nano::uint128_union (10), block_data.second.get ()->amount); - ASSERT_EQ (nano::genesis_account, block_data.second.get ()->source); + ASSERT_EQ (nano::dev::genesis->account (), block_data.second.get ()->source); ASSERT_EQ (nullptr, request->get_next ().first.get ()); } { - auto req = std::make_unique (); + auto req = std::make_unique (nano::dev::network_params.network); req->account = key1.pub; req->minimum_amount = 0; req->flags = nano::bulk_pull_account_flags::pending_address_only; @@ -1902,7 +1889,7 @@ TEST (bulk_pull_account, basics) auto block_data (request->get_next ()); ASSERT_NE (nullptr, block_data.first.get ()); ASSERT_NE (nullptr, block_data.second.get ()); - ASSERT_EQ (nano::genesis_account, block_data.second.get ()->source); + ASSERT_EQ (nano::dev::genesis->account (), block_data.second.get ()->source); block_data = request->get_next (); ASSERT_EQ (nullptr, block_data.first.get ()); ASSERT_EQ (nullptr, block_data.second.get ()); diff --git a/nano/core_test/confirmation_height.cpp b/nano/core_test/confirmation_height.cpp index 7ff7f11991..ac6909e827 100644 --- a/nano/core_test/confirmation_height.cpp +++ b/nano/core_test/confirmation_height.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include @@ -12,7 +12,7 @@ namespace { void add_callback_stats (nano::node & node, std::vector * observer_order = nullptr, nano::mutex * mutex = nullptr) { - node.observers.blocks.add ([&stats = node.stats, observer_order, mutex] (nano::election_status const & status_a, std::vector const &, nano::account const &, nano::amount const &, bool) { + node.observers.blocks.add ([&stats = node.stats, observer_order, mutex] (nano::election_status const & status_a, std::vector const &, nano::account const &, nano::amount const &, bool, bool) { stats.inc (nano::stat::type::http_callback, nano::stat::detail::http_callback, nano::stat::dir::out); if (mutex) { @@ -38,17 +38,17 @@ TEST (confirmation_height, single) node_flags.confirmation_height_processor_mode = mode_a; auto node = system.add_node (node_flags); nano::keypair key1; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - nano::block_hash latest1 (node->latest (nano::dev_genesis_key.pub)); - auto send1 (std::make_shared (nano::dev_genesis_key.pub, latest1, nano::dev_genesis_key.pub, amount - 100, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest1))); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + nano::block_hash latest1 (node->latest (nano::dev::genesis_key.pub)); + auto send1 (std::make_shared (nano::dev::genesis_key.pub, latest1, nano::dev::genesis_key.pub, amount - 100, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1))); // Check confirmation heights before, should be uninitialized (1 for genesis). nano::confirmation_height_info confirmation_height_info; add_callback_stats (*node); auto transaction = node->store.tx_begin_read (); - ASSERT_FALSE (node->store.confirmation_height_get (transaction, nano::dev_genesis_key.pub, confirmation_height_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); - ASSERT_EQ (nano::genesis_hash, confirmation_height_info.frontier); + ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); node->process_active (send1); node->block_processor.flush (); @@ -58,7 +58,7 @@ TEST (confirmation_height, single) { auto transaction = node->store.tx_begin_write (); ASSERT_TRUE (node->ledger.block_confirmed (transaction, send1->hash ())); - ASSERT_FALSE (node->store.confirmation_height_get (transaction, nano::dev_genesis_key.pub, confirmation_height_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (2, confirmation_height_info.height); ASSERT_EQ (send1->hash (), confirmation_height_info.frontier); @@ -90,17 +90,17 @@ TEST (confirmation_height, multiple_accounts) nano::keypair key1; nano::keypair key2; nano::keypair key3; - nano::block_hash latest1 (system.nodes[0]->latest (nano::dev_genesis_key.pub)); + nano::block_hash latest1 (system.nodes[0]->latest (nano::dev::genesis_key.pub)); // Send to all accounts - nano::send_block send1 (latest1, key1.pub, node->online_reps.delta () + 300, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest1)); - nano::send_block send2 (send1.hash (), key2.pub, node->online_reps.delta () + 200, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1.hash ())); - nano::send_block send3 (send2.hash (), key3.pub, node->online_reps.delta () + 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send2.hash ())); + nano::send_block send1 (latest1, key1.pub, node->online_reps.delta () + 300, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1)); + nano::send_block send2 (send1.hash (), key2.pub, node->online_reps.delta () + 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ())); + nano::send_block send3 (send2.hash (), key3.pub, node->online_reps.delta () + 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2.hash ())); // Open all accounts - nano::open_block open1 (send1.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); - nano::open_block open2 (send2.hash (), nano::genesis_account, key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); - nano::open_block open3 (send3.hash (), nano::genesis_account, key3.pub, key3.prv, key3.pub, *system.work.generate (key3.pub)); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); + nano::open_block open2 (send2.hash (), nano::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); + nano::open_block open3 (send3.hash (), nano::dev::genesis->account (), key3.pub, key3.prv, key3.pub, *system.work.generate (key3.pub)); // Send and receive various blocks to these accounts nano::send_block send4 (open1.hash (), key2.pub, 50, key1.prv, key1.pub, *system.work.generate (open1.hash ())); @@ -132,16 +132,16 @@ TEST (confirmation_height, multiple_accounts) // Check confirmation heights of all the accounts (except genesis) are uninitialized (0), // as we have any just added them to the ledger and not processed any live transactions yet. nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (node->store.confirmation_height_get (transaction, nano::dev_genesis_key.pub, confirmation_height_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); - ASSERT_EQ (nano::genesis_hash, confirmation_height_info.frontier); - ASSERT_TRUE (node->store.confirmation_height_get (transaction, key1.pub, confirmation_height_info)); + ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); + ASSERT_TRUE (node->store.confirmation_height.get (transaction, key1.pub, confirmation_height_info)); ASSERT_EQ (0, confirmation_height_info.height); ASSERT_EQ (nano::block_hash (0), confirmation_height_info.frontier); - ASSERT_TRUE (node->store.confirmation_height_get (transaction, key2.pub, confirmation_height_info)); + ASSERT_TRUE (node->store.confirmation_height.get (transaction, key2.pub, confirmation_height_info)); ASSERT_EQ (0, confirmation_height_info.height); ASSERT_EQ (nano::block_hash (0), confirmation_height_info.frontier); - ASSERT_TRUE (node->store.confirmation_height_get (transaction, key3.pub, confirmation_height_info)); + ASSERT_TRUE (node->store.confirmation_height.get (transaction, key3.pub, confirmation_height_info)); ASSERT_EQ (0, confirmation_height_info.height); ASSERT_EQ (nano::block_hash (0), confirmation_height_info.frontier); } @@ -162,23 +162,23 @@ TEST (confirmation_height, multiple_accounts) auto & store = node->store; auto transaction = node->store.tx_begin_read (); ASSERT_TRUE (node->ledger.block_confirmed (transaction, receive3->hash ())); - ASSERT_FALSE (store.account_get (transaction, nano::dev_genesis_key.pub, account_info)); - ASSERT_FALSE (node->store.confirmation_height_get (transaction, nano::dev_genesis_key.pub, confirmation_height_info)); + ASSERT_FALSE (store.account.get (transaction, nano::dev::genesis_key.pub, account_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (4, confirmation_height_info.height); ASSERT_EQ (send3.hash (), confirmation_height_info.frontier); ASSERT_EQ (4, account_info.block_count); - ASSERT_FALSE (store.account_get (transaction, key1.pub, account_info)); - ASSERT_FALSE (node->store.confirmation_height_get (transaction, key1.pub, confirmation_height_info)); + ASSERT_FALSE (store.account.get (transaction, key1.pub, account_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, key1.pub, confirmation_height_info)); ASSERT_EQ (2, confirmation_height_info.height); ASSERT_EQ (send4.hash (), confirmation_height_info.frontier); ASSERT_EQ (3, account_info.block_count); - ASSERT_FALSE (store.account_get (transaction, key2.pub, account_info)); - ASSERT_FALSE (node->store.confirmation_height_get (transaction, key2.pub, confirmation_height_info)); + ASSERT_FALSE (store.account.get (transaction, key2.pub, account_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, key2.pub, confirmation_height_info)); ASSERT_EQ (3, confirmation_height_info.height); ASSERT_EQ (send6.hash (), confirmation_height_info.frontier); ASSERT_EQ (4, account_info.block_count); - ASSERT_FALSE (store.account_get (transaction, key3.pub, account_info)); - ASSERT_FALSE (node->store.confirmation_height_get (transaction, key3.pub, confirmation_height_info)); + ASSERT_FALSE (store.account.get (transaction, key3.pub, account_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, key3.pub, confirmation_height_info)); ASSERT_EQ (2, confirmation_height_info.height); ASSERT_EQ (receive3->hash (), confirmation_height_info.frontier); ASSERT_EQ (2, account_info.block_count); @@ -198,7 +198,7 @@ TEST (confirmation_height, multiple_accounts) // Confirm the other latest can't be rolled back either ASSERT_TRUE (node->ledger.rollback (transaction, node->latest (key3.pub))); - ASSERT_TRUE (node->ledger.rollback (transaction, node->latest (nano::dev_genesis_key.pub))); + ASSERT_TRUE (node->ledger.rollback (transaction, node->latest (nano::dev::genesis_key.pub))); // Attempt some others which have been cemented ASSERT_TRUE (node->ledger.rollback (transaction, open1.hash ())); @@ -223,13 +223,12 @@ TEST (confirmation_height, gap_bootstrap) nano::node_flags node_flags; node_flags.confirmation_height_processor_mode = mode_a; auto & node1 = *system.add_node (node_flags); - nano::genesis genesis; nano::keypair destination; - auto send1 (std::make_shared (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send1); - auto send2 (std::make_shared (nano::genesis_account, send1->hash (), nano::genesis_account, nano::genesis_amount - 2 * nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send2 (std::make_shared (nano::dev::genesis->account (), send1->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send2); - auto send3 (std::make_shared (nano::genesis_account, send2->hash (), nano::genesis_account, nano::genesis_amount - 3 * nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send3 (std::make_shared (nano::dev::genesis->account (), send2->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 3 * nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send3); auto open1 (std::make_shared (send1->hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0)); node1.work_generate_blocking (*open1); @@ -255,13 +254,13 @@ TEST (confirmation_height, gap_bootstrap) // Confirmation heights should not be updated { auto transaction (node1.store.tx_begin_read ()); - auto unchecked_count (node1.store.unchecked_count (transaction)); + auto unchecked_count (node1.store.unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 2); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (node1.store.confirmation_height_get (transaction, nano::dev_genesis_key.pub, confirmation_height_info)); + ASSERT_FALSE (node1.store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); - ASSERT_EQ (genesis.hash (), confirmation_height_info.frontier); + ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); } // Now complete the chain where the block comes in on the bootstrap network. @@ -271,14 +270,14 @@ TEST (confirmation_height, gap_bootstrap) // Confirmation height should be unchanged and unchecked should now be 0 { auto transaction (node1.store.tx_begin_read ()); - auto unchecked_count (node1.store.unchecked_count (transaction)); + auto unchecked_count (node1.store.unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 0); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (node1.store.confirmation_height_get (transaction, nano::dev_genesis_key.pub, confirmation_height_info)); + ASSERT_FALSE (node1.store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); - ASSERT_EQ (genesis.hash (), confirmation_height_info.frontier); - ASSERT_TRUE (node1.store.confirmation_height_get (transaction, destination.pub, confirmation_height_info)); + ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); + ASSERT_TRUE (node1.store.confirmation_height.get (transaction, destination.pub, confirmation_height_info)); ASSERT_EQ (0, confirmation_height_info.height); ASSERT_EQ (nano::block_hash (0), confirmation_height_info.frontier); } @@ -304,18 +303,17 @@ TEST (confirmation_height, gap_live) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config, node_flags); node_config.peering_port = nano::get_available_port (); - node_config.receive_minimum = nano::genesis_amount; // Prevent auto-receive & open1/receive1/receive2 blocks conflicts + node_config.receive_minimum = nano::dev::constants.genesis_amount; // Prevent auto-receive & open1/receive1/receive2 blocks conflicts system.add_node (node_config, node_flags); nano::keypair destination; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (1)->insert_adhoc (destination.prv); - nano::genesis genesis; - auto send1 (std::make_shared (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - 1, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 1, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node->work_generate_blocking (*send1); - auto send2 (std::make_shared (nano::genesis_account, send1->hash (), nano::genesis_account, nano::genesis_amount - 2, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send2 (std::make_shared (nano::dev::genesis->account (), send1->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 2, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node->work_generate_blocking (*send2); - auto send3 (std::make_shared (nano::genesis_account, send2->hash (), nano::genesis_account, nano::genesis_amount - 3, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send3 (std::make_shared (nano::dev::genesis->account (), send2->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 3, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node->work_generate_blocking (*send3); auto open1 (std::make_shared (send1->hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0)); @@ -341,9 +339,9 @@ TEST (confirmation_height, gap_live) { auto transaction = node->store.tx_begin_read (); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (node->store.confirmation_height_get (transaction, nano::dev_genesis_key.pub, confirmation_height_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); - ASSERT_EQ (nano::genesis_hash, confirmation_height_info.frontier); + ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); } // Vote and confirm all existing blocks @@ -358,15 +356,15 @@ TEST (confirmation_height, gap_live) // This should confirm the open block and the source of the receive blocks auto transaction (node->store.tx_begin_read ()); - auto unchecked_count (node->store.unchecked_count (transaction)); + auto unchecked_count (node->store.unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 0); nano::confirmation_height_info confirmation_height_info; ASSERT_TRUE (node->ledger.block_confirmed (transaction, receive2->hash ())); - ASSERT_FALSE (node->store.confirmation_height_get (transaction, nano::dev_genesis_key.pub, confirmation_height_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (4, confirmation_height_info.height); ASSERT_EQ (send3->hash (), confirmation_height_info.frontier); - ASSERT_FALSE (node->store.confirmation_height_get (transaction, destination.pub, confirmation_height_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, destination.pub, confirmation_height_info)); ASSERT_EQ (3, confirmation_height_info.height); ASSERT_EQ (receive2->hash (), confirmation_height_info.frontier); @@ -392,24 +390,24 @@ TEST (confirmation_height, send_receive_between_2_accounts) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config, node_flags); nano::keypair key1; - nano::block_hash latest (node->latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); - nano::send_block send1 (latest, key1.pub, node->online_reps.delta () + 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); + nano::send_block send1 (latest, key1.pub, node->online_reps.delta () + 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); - nano::open_block open1 (send1.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); - nano::send_block send2 (open1.hash (), nano::genesis_account, 1000, key1.prv, key1.pub, *system.work.generate (open1.hash ())); - nano::send_block send3 (send2.hash (), nano::genesis_account, 900, key1.prv, key1.pub, *system.work.generate (send2.hash ())); - nano::send_block send4 (send3.hash (), nano::genesis_account, 500, key1.prv, key1.pub, *system.work.generate (send3.hash ())); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); + nano::send_block send2 (open1.hash (), nano::dev::genesis->account (), 1000, key1.prv, key1.pub, *system.work.generate (open1.hash ())); + nano::send_block send3 (send2.hash (), nano::dev::genesis->account (), 900, key1.prv, key1.pub, *system.work.generate (send2.hash ())); + nano::send_block send4 (send3.hash (), nano::dev::genesis->account (), 500, key1.prv, key1.pub, *system.work.generate (send3.hash ())); - nano::receive_block receive1 (send1.hash (), send2.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1.hash ())); - nano::receive_block receive2 (receive1.hash (), send3.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive1.hash ())); - nano::receive_block receive3 (receive2.hash (), send4.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive2.hash ())); + nano::receive_block receive1 (send1.hash (), send2.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ())); + nano::receive_block receive2 (receive1.hash (), send3.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive1.hash ())); + nano::receive_block receive3 (receive2.hash (), send4.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive2.hash ())); - nano::send_block send5 (receive3.hash (), key1.pub, node->online_reps.delta () + 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive3.hash ())); + nano::send_block send5 (receive3.hash (), key1.pub, node->online_reps.delta () + 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive3.hash ())); auto receive4 = std::make_shared (send4.hash (), send5.hash (), key1.prv, key1.pub, *system.work.generate (send4.hash ())); // Unpocketed send nano::keypair key2; - nano::send_block send6 (send5.hash (), key2.pub, node->online_reps.delta (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send5.hash ())); + nano::send_block send6 (send5.hash (), key2.pub, node->online_reps.delta (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send5.hash ())); { auto transaction = node->store.tx_begin_write (); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code); @@ -443,14 +441,14 @@ TEST (confirmation_height, send_receive_between_2_accounts) ASSERT_TRUE (node->ledger.block_confirmed (transaction, receive4->hash ())); nano::account_info account_info; nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (node->store.account_get (transaction, nano::dev_genesis_key.pub, account_info)); - ASSERT_FALSE (node->store.confirmation_height_get (transaction, nano::dev_genesis_key.pub, confirmation_height_info)); + ASSERT_FALSE (node->store.account.get (transaction, nano::dev::genesis_key.pub, account_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (6, confirmation_height_info.height); ASSERT_EQ (send5.hash (), confirmation_height_info.frontier); ASSERT_EQ (7, account_info.block_count); - ASSERT_FALSE (node->store.account_get (transaction, key1.pub, account_info)); - ASSERT_FALSE (node->store.confirmation_height_get (transaction, key1.pub, confirmation_height_info)); + ASSERT_FALSE (node->store.account.get (transaction, key1.pub, account_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, key1.pub, confirmation_height_info)); ASSERT_EQ (5, confirmation_height_info.height); ASSERT_EQ (receive4->hash (), confirmation_height_info.frontier); ASSERT_EQ (5, account_info.block_count); @@ -476,19 +474,19 @@ TEST (confirmation_height, send_receive_self) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config, node_flags); - nano::block_hash latest (node->latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); - nano::send_block send1 (latest, nano::dev_genesis_key.pub, nano::genesis_amount - 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); - nano::receive_block receive1 (send1.hash (), send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1.hash ())); - nano::send_block send2 (receive1.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive1.hash ())); - nano::send_block send3 (send2.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 3, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send2.hash ())); + nano::send_block send1 (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); + nano::receive_block receive1 (send1.hash (), send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ())); + nano::send_block send2 (receive1.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive1.hash ())); + nano::send_block send3 (send2.hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2.hash ())); - nano::receive_block receive2 (send3.hash (), send2.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send3.hash ())); - auto receive3 = std::make_shared (receive2.hash (), send3.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive2.hash ())); + nano::receive_block receive2 (send3.hash (), send2.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3.hash ())); + auto receive3 = std::make_shared (receive2.hash (), send3.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive2.hash ())); // Send to another account to prevent automatic receiving on the genesis account nano::keypair key1; - nano::send_block send4 (receive3->hash (), key1.pub, node->online_reps.delta (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive3->hash ())); + nano::send_block send4 (receive3->hash (), key1.pub, node->online_reps.delta (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive3->hash ())); { auto transaction = node->store.tx_begin_write (); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code); @@ -513,9 +511,9 @@ TEST (confirmation_height, send_receive_self) auto transaction (node->store.tx_begin_read ()); ASSERT_TRUE (node->ledger.block_confirmed (transaction, receive3->hash ())); nano::account_info account_info; - ASSERT_FALSE (node->store.account_get (transaction, nano::dev_genesis_key.pub, account_info)); + ASSERT_FALSE (node->store.account.get (transaction, nano::dev::genesis_key.pub, account_info)); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (node->store.confirmation_height_get (transaction, nano::dev_genesis_key.pub, confirmation_height_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (7, confirmation_height_info.height); ASSERT_EQ (receive3->hash (), confirmation_height_info.frontier); ASSERT_EQ (8, account_info.block_count); @@ -539,14 +537,14 @@ TEST (confirmation_height, all_block_types) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config, node_flags); - nano::block_hash latest (node->latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); nano::keypair key1; nano::keypair key2; auto & store = node->store; - nano::send_block send (latest, key1.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); - nano::send_block send1 (send.hash (), key2.pub, nano::genesis_amount - nano::MBAN_ratio * 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send.hash ())); + nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); + nano::send_block send1 (send.hash (), key2.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ())); - nano::open_block open (send.hash (), nano::dev_genesis_key.pub, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); + nano::open_block open (send.hash (), nano::dev::genesis_key.pub, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); nano::state_block state_open (key2.pub, 0, 0, nano::MBAN_ratio, send1.hash (), key2.prv, key2.pub, *system.work.generate (key2.pub)); nano::send_block send2 (open.hash (), key2.pub, 0, key1.prv, key1.pub, *system.work.generate (open.hash ())); @@ -557,19 +555,19 @@ TEST (confirmation_height, all_block_types) nano::change_block change (receive.hash (), key2.pub, key1.prv, key1.pub, *system.work.generate (receive.hash ())); - nano::state_block state_change (key2.pub, state_send.hash (), nano::dev_genesis_key.pub, nano::MBAN_ratio, 0, key2.prv, key2.pub, *system.work.generate (state_send.hash ())); + nano::state_block state_change (key2.pub, state_send.hash (), nano::dev::genesis_key.pub, nano::MBAN_ratio, 0, key2.prv, key2.pub, *system.work.generate (state_send.hash ())); - nano::state_block epoch (key2.pub, state_change.hash (), nano::dev_genesis_key.pub, nano::MBAN_ratio, node->ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (state_change.hash ())); + nano::state_block epoch (key2.pub, state_change.hash (), nano::dev::genesis_key.pub, nano::MBAN_ratio, node->ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (state_change.hash ())); - nano::state_block epoch1 (key1.pub, change.hash (), key2.pub, nano::MBAN_ratio, node->ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (change.hash ())); + nano::state_block epoch1 (key1.pub, change.hash (), key2.pub, nano::MBAN_ratio, node->ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (change.hash ())); nano::state_block state_send1 (key1.pub, epoch1.hash (), 0, nano::MBAN_ratio - 1, key2.pub, key1.prv, key1.pub, *system.work.generate (epoch1.hash ())); nano::state_block state_receive2 (key2.pub, epoch.hash (), 0, nano::MBAN_ratio + 1, state_send1.hash (), key2.prv, key2.pub, *system.work.generate (epoch.hash ())); auto state_send2 = std::make_shared (key2.pub, state_receive2.hash (), 0, nano::MBAN_ratio, key1.pub, key2.prv, key2.pub, *system.work.generate (state_receive2.hash ())); nano::state_block state_send3 (key2.pub, state_send2->hash (), 0, nano::MBAN_ratio - 1, key1.pub, key2.prv, key2.pub, *system.work.generate (state_send2->hash ())); - nano::state_block state_send4 (key1.pub, state_send1.hash (), 0, nano::MBAN_ratio - 2, nano::dev_genesis_key.pub, key1.prv, key1.pub, *system.work.generate (state_send1.hash ())); - nano::state_block state_receive3 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio * 2 + 1, state_send4.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1.hash ())); + nano::state_block state_send4 (key1.pub, state_send1.hash (), 0, nano::MBAN_ratio - 2, nano::dev::genesis_key.pub, key1.prv, key1.pub, *system.work.generate (state_send1.hash ())); + nano::state_block state_receive3 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2 + 1, state_send4.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ())); { auto transaction (store.tx_begin_write ()); @@ -611,20 +609,20 @@ TEST (confirmation_height, all_block_types) ASSERT_TRUE (node->ledger.block_confirmed (transaction, state_send2->hash ())); nano::account_info account_info; nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (node->store.account_get (transaction, nano::dev_genesis_key.pub, account_info)); - ASSERT_FALSE (node->store.confirmation_height_get (transaction, nano::dev_genesis_key.pub, confirmation_height_info)); + ASSERT_FALSE (node->store.account.get (transaction, nano::dev::genesis_key.pub, account_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (3, confirmation_height_info.height); ASSERT_EQ (send1.hash (), confirmation_height_info.frontier); ASSERT_LE (4, account_info.block_count); - ASSERT_FALSE (node->store.account_get (transaction, key1.pub, account_info)); - ASSERT_FALSE (node->store.confirmation_height_get (transaction, key1.pub, confirmation_height_info)); + ASSERT_FALSE (node->store.account.get (transaction, key1.pub, account_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, key1.pub, confirmation_height_info)); ASSERT_EQ (state_send1.hash (), confirmation_height_info.frontier); ASSERT_EQ (6, confirmation_height_info.height); ASSERT_LE (7, account_info.block_count); - ASSERT_FALSE (node->store.account_get (transaction, key2.pub, account_info)); - ASSERT_FALSE (node->store.confirmation_height_get (transaction, key2.pub, confirmation_height_info)); + ASSERT_FALSE (node->store.account.get (transaction, key2.pub, account_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, key2.pub, confirmation_height_info)); ASSERT_EQ (7, confirmation_height_info.height); ASSERT_EQ (state_send2->hash (), confirmation_height_info.frontier); ASSERT_LE (8, account_info.block_count); @@ -655,47 +653,46 @@ TEST (confirmation_height, conflict_rollback_cemented) auto node2 = system.add_node (node_flags); ASSERT_EQ (1, node1->network.size ()); nano::keypair key1; - nano::genesis genesis; - auto send1 (std::make_shared (genesis.hash (), key1.pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (genesis.hash ()))); - nano::publish publish1 (send1); + auto send1 (std::make_shared (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); + nano::publish publish1{ nano::dev::network_params.network, send1 }; nano::keypair key2; - auto send2 (std::make_shared (genesis.hash (), key2.pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (genesis.hash ()))); - nano::publish publish2 (send2); + auto send2 (std::make_shared (nano::dev::genesis->hash (), key2.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); + nano::publish publish2{ nano::dev::network_params.network, send2 }; auto channel1 (node1->network.udp_channels.create (node1->network.endpoint ())); - node1->network.process_message (publish1, channel1); + node1->network.inbound (publish1, channel1); node1->block_processor.flush (); node1->scheduler.flush (); auto channel2 (node2->network.udp_channels.create (node1->network.endpoint ())); - node2->network.process_message (publish2, channel2); + node2->network.inbound (publish2, channel2); node2->block_processor.flush (); node2->scheduler.flush (); ASSERT_EQ (1, node1->active.size ()); ASSERT_EQ (1, node2->active.size ()); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - node1->network.process_message (publish2, channel1); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + node1->network.inbound (publish2, channel1); node1->block_processor.flush (); - node2->network.process_message (publish1, channel2); + node2->network.inbound (publish1, channel2); node2->block_processor.flush (); - auto election (node2->active.election (nano::qualified_root (genesis.hash (), genesis.hash ()))); + auto election (node2->active.election (nano::qualified_root (nano::dev::genesis->hash (), nano::dev::genesis->hash ()))); ASSERT_NE (nullptr, election); ASSERT_EQ (1, election->votes ().size ()); // Force blocks to be cemented on both nodes { auto transaction (node1->store.tx_begin_write ()); - ASSERT_TRUE (node1->store.block_exists (transaction, publish1.block->hash ())); - node1->store.confirmation_height_put (transaction, nano::genesis_account, nano::confirmation_height_info{ 2, send2->hash () }); + ASSERT_TRUE (node1->store.block.exists (transaction, publish1.block->hash ())); + node1->store.confirmation_height.put (transaction, nano::dev::genesis->account (), nano::confirmation_height_info{ 2, send2->hash () }); } { auto transaction (node2->store.tx_begin_write ()); - ASSERT_TRUE (node2->store.block_exists (transaction, publish2.block->hash ())); - node2->store.confirmation_height_put (transaction, nano::genesis_account, nano::confirmation_height_info{ 2, send2->hash () }); + ASSERT_TRUE (node2->store.block.exists (transaction, publish2.block->hash ())); + node2->store.confirmation_height.put (transaction, nano::dev::genesis->account (), nano::confirmation_height_info{ 2, send2->hash () }); } auto rollback_log_entry = boost::str (boost::format ("Failed to roll back %1%") % send2->hash ().to_string ()); ASSERT_TIMELY (20s, sb.component ()->str ().find (rollback_log_entry) != std::string::npos); auto winner (*election->tally ().begin ()); ASSERT_EQ (*publish1.block, *winner.second); - ASSERT_EQ (nano::genesis_amount - 100, winner.first); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, winner.first); ASSERT_TRUE (node1->ledger.block_or_pruned_exists (publish1.block->hash ())); ASSERT_TRUE (node2->ledger.block_or_pruned_exists (publish2.block->hash ())); ASSERT_FALSE (node2->ledger.block_or_pruned_exists (publish1.block->hash ())); @@ -707,7 +704,7 @@ TEST (confirmation_height, conflict_rollback_cemented) TEST (confirmation_heightDeathTest, rollback_added_block) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; @@ -721,18 +718,17 @@ TEST (confirmation_heightDeathTest, rollback_added_block) nano::logger_mt logger; nano::logging logging; auto path (nano::unique_path ()); - auto store = nano::make_store (logger, path); + auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); - nano::genesis genesis; nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); nano::write_database_queue write_database_queue (false); - nano::work_pool pool (std::numeric_limits::max ()); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - auto send = std::make_shared (genesis.hash (), key1.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + auto send = std::make_shared (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); { auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); + store->initialize (transaction, ledger.cache); } uint64_t batch_write_size = 2048; @@ -759,9 +755,9 @@ TEST (confirmation_height, observers) node_flags.confirmation_height_processor_mode = mode_a; auto node1 = system.add_node (node_flags); nano::keypair key1; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - nano::block_hash latest1 (node1->latest (nano::dev_genesis_key.pub)); - auto send1 (std::make_shared (latest1, key1.pub, amount - node1->config.receive_minimum.number (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest1))); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + nano::block_hash latest1 (node1->latest (nano::dev::genesis_key.pub)); + auto send1 (std::make_shared (latest1, key1.pub, amount - node1->config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1))); add_callback_stats (*node1); @@ -784,7 +780,7 @@ TEST (confirmation_height, observers) // This tests when a read has been done, but the block no longer exists by the time a write is done TEST (confirmation_heightDeathTest, modified_chain) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; @@ -798,18 +794,17 @@ TEST (confirmation_heightDeathTest, modified_chain) nano::logging logging; nano::logger_mt logger; auto path (nano::unique_path ()); - auto store = nano::make_store (logger, path); + auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); - nano::genesis genesis; nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); nano::write_database_queue write_database_queue (false); - nano::work_pool pool (std::numeric_limits::max ()); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - auto send = std::make_shared (nano::genesis_hash, key1.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::genesis_hash)); + auto send = std::make_shared (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); { auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); + store->initialize (transaction, ledger.cache); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); } @@ -832,7 +827,7 @@ TEST (confirmation_heightDeathTest, modified_chain) } ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *send).code); - store->confirmation_height_put (store->tx_begin_write (), nano::genesis_account, { 1, nano::genesis_hash }); + store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () }); nano::confirmation_height_unbounded unbounded_processor ( ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); @@ -855,7 +850,7 @@ TEST (confirmation_heightDeathTest, modified_chain) // This tests when a read has been done, but the account no longer exists by the time a write is done TEST (confirmation_heightDeathTest, modified_chain_account_removed) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; @@ -869,19 +864,18 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) nano::logging logging; nano::logger_mt logger; auto path (nano::unique_path ()); - auto store = nano::make_store (logger, path); + auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); - nano::genesis genesis; nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); nano::write_database_queue write_database_queue (false); - nano::work_pool pool (std::numeric_limits::max ()); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - auto send = std::make_shared (nano::genesis_hash, key1.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::genesis_hash)); + auto send = std::make_shared (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); auto open = std::make_shared (key1.pub, 0, 0, nano::MBAN_ratio, send->hash (), key1.prv, key1.pub, *pool.generate (key1.pub)); { auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); + store->initialize (transaction, ledger.cache); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); } @@ -906,7 +900,7 @@ TEST (confirmation_heightDeathTest, modified_chain_account_removed) // Reset conditions and test with the bounded processor ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), *open).code); - store->confirmation_height_put (store->tx_begin_write (), nano::genesis_account, { 1, nano::genesis_hash }); + store->confirmation_height.put (store->tx_begin_write (), nano::dev::genesis->account (), { 1, nano::dev::genesis->hash () }); nano::confirmation_height_bounded bounded_processor ( ledger, write_database_queue, 10ms, logging, logger, stopped, batch_write_size, [] (auto const &) {}, [] (auto const &) {}, [] () { return 0; }); @@ -936,12 +930,12 @@ TEST (confirmation_height, pending_observer_callbacks) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config, node_flags); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - nano::block_hash latest (node->latest (nano::dev_genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); nano::keypair key1; - nano::send_block send (latest, key1.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); - auto send1 = std::make_shared (send.hash (), key1.pub, nano::genesis_amount - nano::MBAN_ratio * 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send.hash ())); + nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); + auto send1 = std::make_shared (send.hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ())); { auto transaction = node->store.tx_begin_write (); @@ -979,16 +973,16 @@ TEST (confirmation_height, callback_confirmed_history) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config, node_flags); - nano::block_hash latest (node->latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); nano::keypair key1; - auto send = std::make_shared (latest, key1.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); + auto send = std::make_shared (latest, key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); { auto transaction = node->store.tx_begin_write (); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); } - auto send1 = std::make_shared (send->hash (), key1.pub, nano::genesis_amount - nano::MBAN_ratio * 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send->hash ())); + auto send1 = std::make_shared (send->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ())); add_callback_stats (*node); @@ -1060,12 +1054,12 @@ TEST (confirmation_height, dependent_election) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config, node_flags); - nano::block_hash latest (node->latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); nano::keypair key1; - auto send = std::make_shared (latest, key1.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); - auto send1 = std::make_shared (send->hash (), key1.pub, nano::genesis_amount - nano::MBAN_ratio * 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send->hash ())); - auto send2 = std::make_shared (send1->hash (), key1.pub, nano::genesis_amount - nano::MBAN_ratio * 3, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ())); + auto send = std::make_shared (latest, key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); + auto send1 = std::make_shared (send->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ())); + auto send2 = std::make_shared (send1->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())); { auto transaction = node->store.tx_begin_write (); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); @@ -1110,29 +1104,29 @@ TEST (confirmation_height, cemented_gap_below_receive) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config, node_flags); - nano::block_hash latest (node->latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); nano::keypair key1; system.wallet (0)->insert_adhoc (key1.prv); - nano::send_block send (latest, key1.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); - nano::send_block send1 (send.hash (), key1.pub, nano::genesis_amount - nano::MBAN_ratio * 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send.hash ())); + nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); + nano::send_block send1 (send.hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ())); nano::keypair dummy_key; - nano::send_block dummy_send (send1.hash (), dummy_key.pub, nano::genesis_amount - nano::MBAN_ratio * 3, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1.hash ())); + nano::send_block dummy_send (send1.hash (), dummy_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ())); - nano::open_block open (send.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); + nano::open_block open (send.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); nano::receive_block receive1 (open.hash (), send1.hash (), key1.prv, key1.pub, *system.work.generate (open.hash ())); - nano::send_block send2 (receive1.hash (), nano::dev_genesis_key.pub, nano::MBAN_ratio, key1.prv, key1.pub, *system.work.generate (receive1.hash ())); + nano::send_block send2 (receive1.hash (), nano::dev::genesis_key.pub, nano::MBAN_ratio, key1.prv, key1.pub, *system.work.generate (receive1.hash ())); - nano::receive_block receive2 (dummy_send.hash (), send2.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (dummy_send.hash ())); - nano::send_block dummy_send1 (receive2.hash (), dummy_key.pub, nano::genesis_amount - nano::MBAN_ratio * 3, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive2.hash ())); + nano::receive_block receive2 (dummy_send.hash (), send2.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (dummy_send.hash ())); + nano::send_block dummy_send1 (receive2.hash (), dummy_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive2.hash ())); nano::keypair key2; system.wallet (0)->insert_adhoc (key2.prv); - nano::send_block send3 (dummy_send1.hash (), key2.pub, nano::genesis_amount - nano::MBAN_ratio * 4, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (dummy_send1.hash ())); - nano::send_block dummy_send2 (send3.hash (), dummy_key.pub, nano::genesis_amount - nano::MBAN_ratio * 5, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send3.hash ())); + nano::send_block send3 (dummy_send1.hash (), key2.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 4, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (dummy_send1.hash ())); + nano::send_block dummy_send2 (send3.hash (), dummy_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 5, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3.hash ())); - auto open1 = std::make_shared (send3.hash (), nano::genesis_account, key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); + auto open1 = std::make_shared (send3.hash (), nano::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); { auto transaction = node->store.tx_begin_write (); @@ -1195,29 +1189,29 @@ TEST (confirmation_height, cemented_gap_below_no_cache) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config, node_flags); - nano::block_hash latest (node->latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); nano::keypair key1; system.wallet (0)->insert_adhoc (key1.prv); - nano::send_block send (latest, key1.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); - nano::send_block send1 (send.hash (), key1.pub, nano::genesis_amount - nano::MBAN_ratio * 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send.hash ())); + nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); + nano::send_block send1 (send.hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ())); nano::keypair dummy_key; - nano::send_block dummy_send (send1.hash (), dummy_key.pub, nano::genesis_amount - nano::MBAN_ratio * 3, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1.hash ())); + nano::send_block dummy_send (send1.hash (), dummy_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ())); - nano::open_block open (send.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); + nano::open_block open (send.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); nano::receive_block receive1 (open.hash (), send1.hash (), key1.prv, key1.pub, *system.work.generate (open.hash ())); - nano::send_block send2 (receive1.hash (), nano::dev_genesis_key.pub, nano::MBAN_ratio, key1.prv, key1.pub, *system.work.generate (receive1.hash ())); + nano::send_block send2 (receive1.hash (), nano::dev::genesis_key.pub, nano::MBAN_ratio, key1.prv, key1.pub, *system.work.generate (receive1.hash ())); - nano::receive_block receive2 (dummy_send.hash (), send2.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (dummy_send.hash ())); - nano::send_block dummy_send1 (receive2.hash (), dummy_key.pub, nano::genesis_amount - nano::MBAN_ratio * 3, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive2.hash ())); + nano::receive_block receive2 (dummy_send.hash (), send2.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (dummy_send.hash ())); + nano::send_block dummy_send1 (receive2.hash (), dummy_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive2.hash ())); nano::keypair key2; system.wallet (0)->insert_adhoc (key2.prv); - nano::send_block send3 (dummy_send1.hash (), key2.pub, nano::genesis_amount - nano::MBAN_ratio * 4, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (dummy_send1.hash ())); - nano::send_block dummy_send2 (send3.hash (), dummy_key.pub, nano::genesis_amount - nano::MBAN_ratio * 5, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send3.hash ())); + nano::send_block send3 (dummy_send1.hash (), key2.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 4, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (dummy_send1.hash ())); + nano::send_block dummy_send2 (send3.hash (), dummy_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 5, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3.hash ())); - auto open1 = std::make_shared (send3.hash (), nano::genesis_account, key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); + auto open1 = std::make_shared (send3.hash (), nano::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); { auto transaction = node->store.tx_begin_write (); @@ -1241,8 +1235,8 @@ TEST (confirmation_height, cemented_gap_below_no_cache) // Force some blocks to be cemented so that the cached confirmed info variable is empty { auto transaction (node->store.tx_begin_write ()); - node->store.confirmation_height_put (transaction, nano::genesis_account, nano::confirmation_height_info{ 3, send1.hash () }); - node->store.confirmation_height_put (transaction, key1.pub, nano::confirmation_height_info{ 2, receive1.hash () }); + node->store.confirmation_height.put (transaction, nano::dev::genesis->account (), nano::confirmation_height_info{ 3, send1.hash () }); + node->store.confirmation_height.put (transaction, key1.pub, nano::confirmation_height_info{ 2, receive1.hash () }); } add_callback_stats (*node); @@ -1278,12 +1272,12 @@ TEST (confirmation_height, election_winner_details_clearing) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config, node_flags); - nano::block_hash latest (node->latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); nano::keypair key1; - auto send = std::make_shared (latest, key1.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); - auto send1 = std::make_shared (send->hash (), key1.pub, nano::genesis_amount - nano::MBAN_ratio * 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send->hash ())); - auto send2 = std::make_shared (send1->hash (), key1.pub, nano::genesis_amount - nano::MBAN_ratio * 3, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ())); + auto send = std::make_shared (latest, key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); + auto send1 = std::make_shared (send->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send->hash ())); + auto send2 = std::make_shared (send1->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 3, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ())); { auto transaction = node->store.tx_begin_write (); @@ -1344,7 +1338,7 @@ TEST (confirmation_height, election_winner_details_clearing_node_process_confirm nano::system system (1); auto node = system.nodes.front (); - auto send = std::make_shared (nano::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash)); + auto send = std::make_shared (nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())); // Add to election_winner_details. Use an unrealistic iteration so that it should fall into the else case and do a cleanup node->active.add_election_winner_details (send->hash (), nullptr); nano::election_status election; @@ -1355,28 +1349,27 @@ TEST (confirmation_height, election_winner_details_clearing_node_process_confirm TEST (confirmation_height, unbounded_block_cache_iteration) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; } nano::logger_mt logger; auto path (nano::unique_path ()); - auto store = nano::make_store (logger, path); + auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); - nano::genesis genesis; nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); nano::write_database_queue write_database_queue (false); boost::latch initialized_latch{ 0 }; - nano::work_pool pool (std::numeric_limits::max ()); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::logging logging; nano::keypair key1; - auto send = std::make_shared (genesis.hash (), key1.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); - auto send1 = std::make_shared (send->hash (), key1.pub, nano::genesis_amount - nano::MBAN_ratio * 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send->hash ())); + auto send = std::make_shared (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); + auto send1 = std::make_shared (send->hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send->hash ())); { auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); + store->initialize (transaction, ledger.cache); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); } @@ -1413,23 +1406,22 @@ TEST (confirmation_height, pruned_source) nano::logger_mt logger; nano::logging logging; auto path (nano::unique_path ()); - auto store = nano::make_store (logger, path); + auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); - nano::genesis genesis; nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); ledger.pruning = true; nano::write_database_queue write_database_queue (false); - nano::work_pool pool (std::numeric_limits::max ()); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1, key2; - auto send1 = std::make_shared (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 100, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::genesis_hash)); + auto send1 = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 100, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); auto open1 = std::make_shared (key1.pub, 0, key1.pub, 100, send1->hash (), key1.prv, key1.pub, *pool.generate (key1.pub)); auto send2 = std::make_shared (key1.pub, open1->hash (), key1.pub, 50, key2.pub, key1.prv, key1.pub, *pool.generate (open1->hash ())); auto send3 = std::make_shared (key1.pub, send2->hash (), key1.pub, 25, key2.pub, key1.prv, key1.pub, *pool.generate (send2->hash ())); auto open2 = std::make_shared (key2.pub, 0, key1.pub, 50, send2->hash (), key2.prv, key2.pub, *pool.generate (key2.pub)); { auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); + store->initialize (transaction, ledger.cache); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open1).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); diff --git a/nano/core_test/confirmation_solicitor.cpp b/nano/core_test/confirmation_solicitor.cpp index 907ef5fede..fe9db15e91 100644 --- a/nano/core_test/confirmation_solicitor.cpp +++ b/nano/core_test/confirmation_solicitor.cpp @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include @@ -19,16 +19,16 @@ TEST (confirmation_solicitor, batches) auto & node2 = *system.add_node (node_flags); auto channel1 (node2.network.udp_channels.create (node1.network.endpoint ())); // Solicitor will only solicit from this representative - nano::representative representative (nano::dev_genesis_key.pub, nano::genesis_amount, channel1); + nano::representative representative (nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, channel1); std::vector representatives{ representative }; nano::confirmation_solicitor solicitor (node2.network, node2.config); solicitor.prepare (representatives); // Ensure the representatives are correct ASSERT_EQ (1, representatives.size ()); ASSERT_EQ (channel1, representatives.front ().channel); - ASSERT_EQ (nano::dev_genesis_key.pub, representatives.front ().account); + ASSERT_EQ (nano::dev::genesis_key.pub, representatives.front ().account); ASSERT_TIMELY (3s, node2.network.size () == 1); - auto send (std::make_shared (nano::genesis_hash, nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash))); + auto send (std::make_shared (nano::dev::genesis->hash (), nano::keypair ().pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); send->sideband_set ({}); { nano::lock_guard guard (node2.active.mutex); @@ -63,16 +63,16 @@ TEST (confirmation_solicitor, different_hash) auto & node2 = *system.add_node (node_flags); auto channel1 (node2.network.udp_channels.create (node1.network.endpoint ())); // Solicitor will only solicit from this representative - nano::representative representative (nano::dev_genesis_key.pub, nano::genesis_amount, channel1); + nano::representative representative (nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, channel1); std::vector representatives{ representative }; nano::confirmation_solicitor solicitor (node2.network, node2.config); solicitor.prepare (representatives); // Ensure the representatives are correct ASSERT_EQ (1, representatives.size ()); ASSERT_EQ (channel1, representatives.front ().channel); - ASSERT_EQ (nano::dev_genesis_key.pub, representatives.front ().account); + ASSERT_EQ (nano::dev::genesis_key.pub, representatives.front ().account); ASSERT_TIMELY (3s, node2.network.size () == 1); - auto send (std::make_shared (nano::genesis_hash, nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash))); + auto send (std::make_shared (nano::dev::genesis->hash (), nano::keypair ().pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); send->sideband_set ({}); auto election (std::make_shared (node2, send, nullptr, nullptr, nano::election_behavior::normal)); // Add a vote for something else, not the winner @@ -108,7 +108,7 @@ TEST (confirmation_solicitor, bypass_max_requests_cap) ASSERT_EQ (max_representatives + 1, representatives.size ()); solicitor.prepare (representatives); ASSERT_TIMELY (3s, node2.network.size () == 1); - auto send (std::make_shared (nano::genesis_hash, nano::keypair ().pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash))); + auto send (std::make_shared (nano::dev::genesis->hash (), nano::keypair ().pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); send->sideband_set ({}); auto election (std::make_shared (node2, send, nullptr, nullptr, nano::election_behavior::normal)); // Add a vote for something else, not the winner diff --git a/nano/core_test/conflicts.cpp b/nano/core_test/conflicts.cpp index 1bbb1a8c45..a4aaeb94de 100644 --- a/nano/core_test/conflicts.cpp +++ b/nano/core_test/conflicts.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include @@ -12,13 +12,12 @@ TEST (conflicts, start_stop) { nano::system system (1); auto & node1 (*system.nodes[0]); - nano::genesis genesis; nano::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send1); ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); ASSERT_EQ (0, node1.active.size ()); - node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ()); + node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); node1.scheduler.flush (); auto election1 = node1.active.election (send1->qualified_root ()); ASSERT_EQ (1, node1.active.size ()); @@ -30,21 +29,20 @@ TEST (conflicts, add_existing) { nano::system system (1); auto & node1 (*system.nodes[0]); - nano::genesis genesis; nano::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send1); ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); - node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ()); + node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); nano::keypair key2; - auto send2 (std::make_shared (genesis.hash (), key2.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send2 (std::make_shared (nano::dev::genesis->hash (), key2.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); send2->sideband_set ({}); - node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ()); + node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); node1.scheduler.flush (); auto election1 = node1.active.election (send2->qualified_root ()); ASSERT_NE (nullptr, election1); ASSERT_EQ (1, node1.active.size ()); - auto vote1 (std::make_shared (key2.pub, key2.prv, 0, send2)); + auto vote1 (std::make_shared (key2.pub, key2.prv, 0, 0, send2)); node1.active.vote (vote1); ASSERT_EQ (2, election1->votes ().size ()); auto votes (election1->votes ()); @@ -53,22 +51,95 @@ TEST (conflicts, add_existing) TEST (conflicts, add_two) { - nano::system system (1); - auto & node1 (*system.nodes[0]); - nano::genesis genesis; - nano::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); - node1.work_generate_blocking (*send1); - ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); - node1.block_confirm (send1); - node1.active.election (send1->qualified_root ())->force_confirm (); - nano::keypair key2; - auto send2 (std::make_shared (send1->hash (), key2.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); - node1.work_generate_blocking (*send2); - ASSERT_EQ (nano::process_result::progress, node1.process (*send2).code); - node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ()); - node1.scheduler.flush (); - ASSERT_EQ (2, node1.active.size ()); + nano::system system{}; + auto const & node = system.add_node (); + + // define a functor that sends from given account to given destination, + // optionally force-confirming the send blocks *and* receiving on the destination account; + // the functor returns a pair of the send and receive blocks created or nullptrs if something failed + // + auto const do_send = [&node] (auto const & previous, auto const & from, auto const & to, bool forceConfirm = true) + -> std::pair, std::shared_ptr> { + auto send = std::make_shared (previous->hash (), to.pub, 0, from.prv, from.pub, 0); + node->work_generate_blocking (*send); + + if (nano::process_result::progress != node->process (*send).code) + { + send.reset (); + return std::make_pair (std::move (send), std::move (send)); + } + + if (forceConfirm) + { + node->block_confirm (send); + node->active.election (send->qualified_root ())->force_confirm (); + + auto receive = std::make_shared (send->hash (), to.pub, to.pub, to.prv, to.pub, 0); + node->work_generate_blocking (*receive); + + if (nano::process_result::progress != node->process (*receive).code) + { + return std::make_pair (nullptr, nullptr); + } + + node->block_confirm (receive); + node->active.election (receive->qualified_root ())->force_confirm (); + + return std::make_pair (std::move (send), std::move (receive)); + } + + return std::make_pair (std::move (send), nullptr); + }; + + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + + // send from genesis to account1 and receive it on account1 + // + nano::keypair account1{}; + auto const [send1, receive1] = do_send (nano::dev::genesis, nano::dev::genesis_key, account1); + ASSERT_TRUE (send1 && receive1); + // both blocks having been fully confirmed, we expect 1 (genesis) + 2 (send/receive) = 3 cemented blocks + // + ASSERT_TIMELY (3s, 3 == node->ledger.cache.cemented_count); + + // send from genesis to account2 and receive it on account2 + // + nano::keypair account2{}; + auto const [send2, receive2] = do_send (send1, nano::dev::genesis_key, account2); + ASSERT_TRUE (send2 && receive2); + ASSERT_TIMELY (3s, 5 == node->ledger.cache.cemented_count); + + // send from account1 to account3 but do not receive it on account3 and do not force confirm the send block + // + nano::keypair account3{}; + { + auto const [send3, _] = do_send (receive1, account1, account3, false); + ASSERT_TRUE (send3); + // expect the number of cemented blocks not to have changed since the last operation + // + ASSERT_TIMELY (3s, 5 == node->ledger.cache.cemented_count); + } + + // send from account1 to account3 but do not receive it on account3 and do not force confirm the send block + // + { + auto const [send4, _] = do_send (receive2, account2, account3, false); + ASSERT_TRUE (send4); + // expect the number of cemented blocks not to have changed since the last operation + // + ASSERT_TIMELY (3s, 5 == node->ledger.cache.cemented_count); + } + + // activate elections for the previous two send blocks (to account3) that we did not forcefully confirm + // + node->scheduler.activate (account3.pub, node->store.tx_begin_read ()); + node->scheduler.flush (); + + // wait 3s before asserting just to make sure there would be enough time + // for the Active Elections Container to evict both elections in case they would wrongfully get confirmed + // + std::this_thread::sleep_for (3s); + ASSERT_EQ (2, node->active.size ()); } TEST (vote_uniquer, null) @@ -84,7 +155,7 @@ TEST (vote_uniquer, same_vote) nano::block_uniquer block_uniquer; nano::vote_uniquer uniquer (block_uniquer); nano::keypair key; - auto vote1 (std::make_shared (key.pub, key.prv, 0, std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0))); + auto vote1 (std::make_shared (key.pub, key.prv, 0, 0, std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0))); auto vote2 (std::make_shared (*vote1)); ASSERT_EQ (vote1, uniquer.unique (vote1)); ASSERT_EQ (vote1, uniquer.unique (vote2)); @@ -99,8 +170,8 @@ TEST (vote_uniquer, same_block) nano::keypair key2; auto block1 (std::make_shared (0, 0, 0, 0, 0, key1.prv, key1.pub, 0)); auto block2 (std::make_shared (*block1)); - auto vote1 (std::make_shared (key1.pub, key1.prv, 0, block1)); - auto vote2 (std::make_shared (key1.pub, key1.prv, 0, block2)); + auto vote1 (std::make_shared (key1.pub, key1.prv, 0, 0, block1)); + auto vote2 (std::make_shared (key1.pub, key1.prv, 0, 0, block2)); ASSERT_EQ (vote1, uniquer.unique (vote1)); ASSERT_EQ (vote2, uniquer.unique (vote2)); ASSERT_NE (vote1, vote2); @@ -115,7 +186,7 @@ TEST (vote_uniquer, vbh_one) auto block (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0)); std::vector hashes; hashes.push_back (block->hash ()); - auto vote1 (std::make_shared (key.pub, key.prv, 0, hashes)); + auto vote1 (std::make_shared (key.pub, key.prv, 0, 0, hashes)); auto vote2 (std::make_shared (*vote1)); ASSERT_EQ (vote1, uniquer.unique (vote1)); ASSERT_EQ (vote1, uniquer.unique (vote2)); @@ -132,8 +203,8 @@ TEST (vote_uniquer, vbh_two) auto block2 (std::make_shared (1, 0, 0, 0, 0, key.prv, key.pub, 0)); std::vector hashes2; hashes2.push_back (block2->hash ()); - auto vote1 (std::make_shared (key.pub, key.prv, 0, hashes1)); - auto vote2 (std::make_shared (key.pub, key.prv, 0, hashes2)); + auto vote1 (std::make_shared (key.pub, key.prv, 0, 0, hashes1)); + auto vote2 (std::make_shared (key.pub, key.prv, 0, 0, hashes2)); ASSERT_EQ (vote1, uniquer.unique (vote1)); ASSERT_EQ (vote2, uniquer.unique (vote2)); } @@ -143,8 +214,8 @@ TEST (vote_uniquer, cleanup) nano::block_uniquer block_uniquer; nano::vote_uniquer uniquer (block_uniquer); nano::keypair key; - auto vote1 (std::make_shared (key.pub, key.prv, 0, std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0))); - auto vote2 (std::make_shared (key.pub, key.prv, 1, std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0))); + auto vote1 (std::make_shared (key.pub, key.prv, 0, 0, std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0))); + auto vote2 (std::make_shared (key.pub, key.prv, nano::vote::timestamp_min * 1, 0, std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0))); auto vote3 (uniquer.unique (vote1)); auto vote4 (uniquer.unique (vote2)); vote2.reset (); diff --git a/nano/core_test/core_test_main.cc b/nano/core_test/core_test_main.cc index 7bd3e05bf0..ee80f5d628 100644 --- a/nano/core_test/core_test_main.cc +++ b/nano/core_test/core_test_main.cc @@ -2,6 +2,7 @@ #include #include +#include #include @@ -9,7 +10,6 @@ namespace nano { void cleanup_dev_directories_on_exit (); void force_nano_dev_network (); -boost::filesystem::path unique_path (); } GTEST_API_ int main (int argc, char ** argv) diff --git a/nano/core_test/difficulty.cpp b/nano/core_test/difficulty.cpp index 0a4677906a..6918f47645 100644 --- a/nano/core_test/difficulty.cpp +++ b/nano/core_test/difficulty.cpp @@ -3,27 +3,11 @@ #include #include #include -#include +#include #include #include -TEST (system, work_generate_limited) -{ - nano::system system; - nano::block_hash key (1); - nano::network_constants constants; - auto min = constants.publish_thresholds.entry; - auto max = constants.publish_thresholds.base; - for (int i = 0; i < 5; ++i) - { - auto work = system.work_generate_limited (key, min, max); - auto difficulty = nano::work_difficulty (nano::work_version::work_1, key, work); - ASSERT_GE (difficulty, min); - ASSERT_LT (difficulty, max); - } -} - TEST (difficultyDeathTest, multipliers) { // For ASSERT_DEATH_IF_SUPPORTED @@ -39,7 +23,7 @@ TEST (difficultyDeathTest, multipliers) } { - uint64_t base = 0xfffffe0000000000; + uint64_t base = 0xffffffc000000000; uint64_t difficulty = 0xfffffe0000000000; double expected_multiplier = 0.125; @@ -123,12 +107,11 @@ TEST (difficulty, zero) TEST (difficulty, network_constants) { - nano::network_constants constants; - auto & full_thresholds = constants.publish_full; - auto & beta_thresholds = constants.publish_beta; - auto & dev_thresholds = constants.publish_dev; + auto & full_thresholds = nano::work_thresholds::publish_full; + auto & beta_thresholds = nano::work_thresholds::publish_beta; + auto & dev_thresholds = nano::work_thresholds::publish_dev; - ASSERT_NEAR (8., nano::difficulty::to_multiplier (full_thresholds.epoch_2, full_thresholds.epoch_1), 1e-10); + ASSERT_NEAR (1e-10, nano::difficulty::to_multiplier (full_thresholds.epoch_2, full_thresholds.epoch_1), 1e-10); ASSERT_NEAR (1 / 8., nano::difficulty::to_multiplier (full_thresholds.epoch_2_receive, full_thresholds.epoch_1), 1e-10); ASSERT_NEAR (1., nano::difficulty::to_multiplier (full_thresholds.epoch_2_receive, full_thresholds.entry), 1e-10); ASSERT_NEAR (1., nano::difficulty::to_multiplier (full_thresholds.epoch_2, full_thresholds.base), 1e-10); @@ -145,23 +128,23 @@ TEST (difficulty, network_constants) ASSERT_NEAR (1., nano::difficulty::to_multiplier (dev_thresholds.epoch_2, dev_thresholds.base), 1e-10); nano::work_version version{ nano::work_version::work_1 }; - ASSERT_EQ (constants.publish_thresholds.base, constants.publish_thresholds.epoch_2); - ASSERT_EQ (constants.publish_thresholds.base, nano::work_threshold_base (version)); - ASSERT_EQ (constants.publish_thresholds.entry, nano::work_threshold_entry (version, nano::block_type::state)); - ASSERT_EQ (constants.publish_thresholds.epoch_1, nano::work_threshold_entry (version, nano::block_type::send)); - ASSERT_EQ (constants.publish_thresholds.epoch_1, nano::work_threshold_entry (version, nano::block_type::receive)); - ASSERT_EQ (constants.publish_thresholds.epoch_1, nano::work_threshold_entry (version, nano::block_type::open)); - ASSERT_EQ (constants.publish_thresholds.epoch_1, nano::work_threshold_entry (version, nano::block_type::change)); - ASSERT_EQ (constants.publish_thresholds.epoch_1, nano::work_threshold (version, nano::block_details (nano::epoch::epoch_0, false, false, false))); - ASSERT_EQ (constants.publish_thresholds.epoch_1, nano::work_threshold (version, nano::block_details (nano::epoch::epoch_1, false, false, false))); - ASSERT_EQ (constants.publish_thresholds.epoch_1, nano::work_threshold (version, nano::block_details (nano::epoch::epoch_1, false, false, false))); + ASSERT_EQ (nano::dev::network_params.work.base, nano::dev::network_params.work.epoch_2); + ASSERT_EQ (nano::dev::network_params.work.base, nano::dev::network_params.work.threshold_base (version)); + ASSERT_EQ (nano::dev::network_params.work.entry, nano::dev::network_params.work.threshold_entry (version, nano::block_type::state)); + ASSERT_EQ (nano::dev::network_params.work.epoch_1, nano::dev::network_params.work.threshold_entry (version, nano::block_type::send)); + ASSERT_EQ (nano::dev::network_params.work.epoch_1, nano::dev::network_params.work.threshold_entry (version, nano::block_type::receive)); + ASSERT_EQ (nano::dev::network_params.work.epoch_1, nano::dev::network_params.work.threshold_entry (version, nano::block_type::open)); + ASSERT_EQ (nano::dev::network_params.work.epoch_1, nano::dev::network_params.work.threshold_entry (version, nano::block_type::change)); + ASSERT_EQ (nano::dev::network_params.work.epoch_1, nano::dev::network_params.work.threshold (version, nano::block_details (nano::epoch::epoch_0, false, false, false))); + ASSERT_EQ (nano::dev::network_params.work.epoch_1, nano::dev::network_params.work.threshold (version, nano::block_details (nano::epoch::epoch_1, false, false, false))); + ASSERT_EQ (nano::dev::network_params.work.epoch_1, nano::dev::network_params.work.threshold (version, nano::block_details (nano::epoch::epoch_1, false, false, false))); // Send [+ change] - ASSERT_EQ (constants.publish_thresholds.epoch_2, nano::work_threshold (version, nano::block_details (nano::epoch::epoch_2, true, false, false))); + ASSERT_EQ (nano::dev::network_params.work.epoch_2, nano::dev::network_params.work.threshold (version, nano::block_details (nano::epoch::epoch_2, true, false, false))); // Change - ASSERT_EQ (constants.publish_thresholds.epoch_2, nano::work_threshold (version, nano::block_details (nano::epoch::epoch_2, false, false, false))); + ASSERT_EQ (nano::dev::network_params.work.epoch_2, nano::dev::network_params.work.threshold (version, nano::block_details (nano::epoch::epoch_2, false, false, false))); // Receive [+ change] / Open - ASSERT_EQ (constants.publish_thresholds.epoch_2_receive, nano::work_threshold (version, nano::block_details (nano::epoch::epoch_2, false, true, false))); + ASSERT_EQ (nano::dev::network_params.work.epoch_2_receive, nano::dev::network_params.work.threshold (version, nano::block_details (nano::epoch::epoch_2, false, true, false))); // Epoch - ASSERT_EQ (constants.publish_thresholds.epoch_2_receive, nano::work_threshold (version, nano::block_details (nano::epoch::epoch_2, false, false, true))); + ASSERT_EQ (nano::dev::network_params.work.epoch_2_receive, nano::dev::network_params.work.threshold (version, nano::block_details (nano::epoch::epoch_2, false, false, true))); } diff --git a/nano/core_test/distributed_work.cpp b/nano/core_test/distributed_work.cpp index 91a054e903..ce0cfddc38 100644 --- a/nano/core_test/distributed_work.cpp +++ b/nano/core_test/distributed_work.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include @@ -10,7 +10,7 @@ TEST (distributed_work, stopped) { nano::system system (1); system.nodes[0]->distributed_work.stop (); - ASSERT_TRUE (system.nodes[0]->distributed_work.make (nano::work_version::work_1, nano::block_hash (), {}, nano::network_constants ().publish_thresholds.base, {})); + ASSERT_TRUE (system.nodes[0]->distributed_work.make (nano::work_version::work_1, nano::block_hash (), {}, nano::dev::network_params.work.base, {})); } TEST (distributed_work, no_peers) @@ -25,9 +25,9 @@ TEST (distributed_work, no_peers) work = work_a; done = true; }; - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, node->config.work_peers, node->network_params.network.publish_thresholds.base, callback, nano::account ())); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, node->config.work_peers, node->network_params.work.base, callback, nano::account ())); ASSERT_TIMELY (5s, done); - ASSERT_GE (nano::work_difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, *work), node->network_params.work.base); // should only be removed after cleanup ASSERT_EQ (1, node->distributed_work.size ()); while (node->distributed_work.size () > 0) @@ -43,7 +43,7 @@ TEST (distributed_work, no_peers_disabled) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.work_threads = 0; auto & node = *system.add_node (node_config); - ASSERT_TRUE (node.distributed_work.make (nano::work_version::work_1, nano::block_hash (), node.config.work_peers, nano::network_constants ().publish_thresholds.base, {})); + ASSERT_TRUE (node.distributed_work.make (nano::work_version::work_1, nano::block_hash (), node.config.work_peers, nano::dev::network_params.work.base, {})); } TEST (distributed_work, no_peers_cancel) @@ -58,7 +58,7 @@ TEST (distributed_work, no_peers_cancel) ASSERT_FALSE (work_a.is_initialized ()); done = true; }; - ASSERT_FALSE (node.distributed_work.make (nano::work_version::work_1, hash, node.config.work_peers, nano::difficulty::from_multiplier (1e6, node.network_params.network.publish_thresholds.base), callback_to_cancel)); + ASSERT_FALSE (node.distributed_work.make (nano::work_version::work_1, hash, node.config.work_peers, nano::difficulty::from_multiplier (1e6, node.network_params.work.base), callback_to_cancel)); ASSERT_EQ (1, node.distributed_work.size ()); // cleanup should not cancel or remove an ongoing work node.distributed_work.cleanup_finished (); @@ -70,7 +70,7 @@ TEST (distributed_work, no_peers_cancel) // now using observer done = false; - ASSERT_FALSE (node.distributed_work.make (nano::work_version::work_1, hash, node.config.work_peers, nano::difficulty::from_multiplier (1e6, node.network_params.network.publish_thresholds.base), callback_to_cancel)); + ASSERT_FALSE (node.distributed_work.make (nano::work_version::work_1, hash, node.config.work_peers, nano::difficulty::from_multiplier (1e6, node.network_params.work.base), callback_to_cancel)); ASSERT_EQ (1, node.distributed_work.size ()); node.observers.work_cancel.notify (hash); ASSERT_TIMELY (20s, done && node.distributed_work.size () == 0); @@ -90,7 +90,7 @@ TEST (distributed_work, no_peers_multi) // Test many works for the same root for (unsigned i{ 0 }; i < total; ++i) { - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, node->config.work_peers, nano::difficulty::from_multiplier (10, node->network_params.network.publish_thresholds.base), callback)); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, node->config.work_peers, nano::difficulty::from_multiplier (10, node->network_params.work.base), callback)); } ASSERT_TIMELY (5s, count == total); system.deadline_set (5s); @@ -104,7 +104,7 @@ TEST (distributed_work, no_peers_multi) for (unsigned i{ 0 }; i < total; ++i) { nano::block_hash hash_i (i + 1); - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash_i, node->config.work_peers, node->network_params.network.publish_thresholds.base, callback)); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash_i, node->config.work_peers, node->network_params.work.base, callback)); } ASSERT_TIMELY (5s, count == total); system.deadline_set (5s); @@ -136,9 +136,9 @@ TEST (distributed_work, peer) work_peer->start (); decltype (node->config.work_peers) peers; peers.emplace_back ("::ffff:127.0.0.1", work_peer->port ()); - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.network.publish_thresholds.base, callback, nano::account ())); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.work.base, callback, nano::account ())); ASSERT_TIMELY (5s, done); - ASSERT_GE (nano::work_difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, *work), node->network_params.work.base); ASSERT_EQ (1, work_peer->generations_good); ASSERT_EQ (0, work_peer->generations_bad); ASSERT_NO_ERROR (system.poll ()); @@ -162,9 +162,9 @@ TEST (distributed_work, peer_malicious) malicious_peer->start (); decltype (node->config.work_peers) peers; peers.emplace_back ("::ffff:127.0.0.1", malicious_peer->port ()); - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.network.publish_thresholds.base, callback, nano::account ())); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.work.base, callback, nano::account ())); ASSERT_TIMELY (5s, done); - ASSERT_GE (nano::work_difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, *work), node->network_params.work.base); ASSERT_TIMELY (5s, malicious_peer->generations_bad >= 1); // make sure it was *not* the malicious peer that replied ASSERT_EQ (0, malicious_peer->generations_good); @@ -179,7 +179,7 @@ TEST (distributed_work, peer_malicious) auto malicious_peer2 (std::make_shared (node->work, node->io_ctx, nano::get_available_port (), work_peer_type::malicious)); malicious_peer2->start (); peers[0].second = malicious_peer2->port (); - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.network.publish_thresholds.base, {}, nano::account ())); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.work.base, {}, nano::account ())); ASSERT_TIMELY (5s, malicious_peer2->generations_bad >= 2); node->distributed_work.cancel (hash); ASSERT_EQ (0, malicious_peer2->cancels); @@ -208,9 +208,9 @@ TEST (distributed_work, peer_multi) peers.emplace_back ("localhost", malicious_peer->port ()); peers.emplace_back ("localhost", slow_peer->port ()); peers.emplace_back ("localhost", good_peer->port ()); - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.network.publish_thresholds.base, callback, nano::account ())); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.work.base, callback, nano::account ())); ASSERT_TIMELY (5s, done); - ASSERT_GE (nano::work_difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, *work), node->network_params.work.base); ASSERT_TIMELY (5s, slow_peer->cancels == 1); ASSERT_EQ (0, malicious_peer->generations_good); ASSERT_EQ (1, malicious_peer->generations_bad); @@ -239,7 +239,7 @@ TEST (distributed_work, fail_resolve) }; decltype (node->config.work_peers) peers; peers.emplace_back ("beeb.boop.123z", 0); - ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.network.publish_thresholds.base, callback, nano::account ())); + ASSERT_FALSE (node->distributed_work.make (nano::work_version::work_1, hash, peers, node->network_params.work.base, callback, nano::account ())); ASSERT_TIMELY (5s, done); - ASSERT_GE (nano::work_difficulty (nano::work_version::work_1, hash, *work), node->network_params.network.publish_thresholds.base); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, *work), node->network_params.work.base); } diff --git a/nano/core_test/election.cpp b/nano/core_test/election.cpp index 0dabbdec3c..a89d7a5a78 100644 --- a/nano/core_test/election.cpp +++ b/nano/core_test/election.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include @@ -9,12 +9,10 @@ using namespace std::chrono_literals; TEST (election, construction) { nano::system system (1); - nano::genesis genesis; auto & node = *system.nodes[0]; - genesis.open->sideband_set (nano::block_sideband (nano::genesis_account, 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); - node.block_confirm (genesis.open); + node.block_confirm (nano::dev::genesis); node.scheduler.flush (); - auto election = node.active.election (genesis.open->qualified_root ()); + auto election = node.active.election (nano::dev::genesis->qualified_root ()); election->transition_active (); } @@ -22,30 +20,30 @@ TEST (election, quorum_minimum_flip_success) { nano::system system; nano::node_config node_config (nano::get_available_port (), system.logging); - node_config.online_weight_minimum = nano::genesis_amount; + node_config.online_weight_minimum = nano::dev::constants.genesis_amount; node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node1 = *system.add_node (node_config); nano::keypair key1; nano::block_builder builder; auto send1 = builder.state () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .balance (node1.online_reps.delta ()) .link (key1.pub) .work (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build_shared (); node1.work_generate_blocking (*send1); nano::keypair key2; auto send2 = builder.state () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .balance (node1.online_reps.delta ()) .link (key2.pub) .work (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build_shared (); node1.work_generate_blocking (*send2); node1.process_active (send1); @@ -57,7 +55,7 @@ TEST (election, quorum_minimum_flip_success) auto election = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election); ASSERT_EQ (2, election->blocks ().size ()); - auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), send2)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, send2)); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); node1.block_processor.flush (); ASSERT_NE (nullptr, node1.block (send2->hash ())); @@ -68,30 +66,30 @@ TEST (election, quorum_minimum_flip_fail) { nano::system system; nano::node_config node_config (nano::get_available_port (), system.logging); - node_config.online_weight_minimum = nano::genesis_amount; + node_config.online_weight_minimum = nano::dev::constants.genesis_amount; node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node1 = *system.add_node (node_config); nano::keypair key1; nano::block_builder builder; auto send1 = builder.state () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .balance (node1.online_reps.delta () - 1) .link (key1.pub) .work (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build_shared (); node1.work_generate_blocking (*send1); nano::keypair key2; auto send2 = builder.state () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .balance (node1.online_reps.delta () - 1) .link (key2.pub) .work (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build_shared (); node1.work_generate_blocking (*send2); node1.process_active (send1); @@ -103,7 +101,7 @@ TEST (election, quorum_minimum_flip_fail) auto election = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election); ASSERT_EQ (2, election->blocks ().size ()); - auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), send2)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, send2)); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); node1.block_processor.flush (); ASSERT_NE (nullptr, node1.block (send1->hash ())); @@ -114,29 +112,29 @@ TEST (election, quorum_minimum_confirm_success) { nano::system system; nano::node_config node_config (nano::get_available_port (), system.logging); - node_config.online_weight_minimum = nano::genesis_amount; + node_config.online_weight_minimum = nano::dev::constants.genesis_amount; node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node1 = *system.add_node (node_config); nano::keypair key1; nano::block_builder builder; auto send1 = builder.state () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .balance (node1.online_reps.delta ()) .link (key1.pub) .work (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build_shared (); node1.work_generate_blocking (*send1); node1.process_active (send1); node1.block_processor.flush (); - node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ()); + node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); node1.scheduler.flush (); auto election = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election); ASSERT_EQ (1, election->blocks ().size ()); - auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, send1)); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); node1.block_processor.flush (); ASSERT_NE (nullptr, node1.block (send1->hash ())); @@ -147,29 +145,29 @@ TEST (election, quorum_minimum_confirm_fail) { nano::system system; nano::node_config node_config (nano::get_available_port (), system.logging); - node_config.online_weight_minimum = nano::genesis_amount; + node_config.online_weight_minimum = nano::dev::constants.genesis_amount; node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node1 = *system.add_node (node_config); nano::keypair key1; nano::block_builder builder; auto send1 = builder.state () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .balance (node1.online_reps.delta () - 1) .link (key1.pub) .work (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build_shared (); node1.work_generate_blocking (*send1); node1.process_active (send1); node1.block_processor.flush (); - node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ()); + node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); node1.scheduler.flush (); auto election = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election); ASSERT_EQ (1, election->blocks ().size ()); - auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, send1)); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); node1.block_processor.flush (); ASSERT_NE (nullptr, node1.block (send1->hash ())); @@ -178,31 +176,34 @@ TEST (election, quorum_minimum_confirm_fail) namespace nano { -TEST (election, quorum_minimum_update_weight_before_quorum_checks) +// Test disabled because it's failing intermittently. +// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3526 +// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3528 +TEST (election, DISABLED_quorum_minimum_update_weight_before_quorum_checks) { nano::system system; nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node1 = *system.add_node (node_config); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto amount = ((nano::uint256_t (node_config.online_weight_minimum.number ()) * nano::online_reps::online_weight_quorum) / 100).convert_to () - 1; nano::keypair key1; nano::block_builder builder; auto send1 = builder.state () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .balance (amount) .link (key1.pub) .work (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build_shared (); node1.work_generate_blocking (*send1); auto open1 = builder.state () .account (key1.pub) .previous (0) .representative (key1.pub) - .balance (nano::genesis_amount - amount) + .balance (nano::dev::constants.genesis_amount - amount) .link (send1->hash ()) .work (0) .sign (key1.prv, key1.pub) @@ -221,28 +222,28 @@ TEST (election, quorum_minimum_update_weight_before_quorum_checks) node1.work_generate_blocking (*send2); node1.process_active (send1); node1.block_processor.flush (); - node1.process (*open1); - node1.process (*send2); + ASSERT_EQ (nano::process_result::progress, node1.process (*open1).code); + ASSERT_EQ (nano::process_result::progress, node1.process (*send2).code); node1.block_processor.flush (); ASSERT_EQ (node1.ledger.cache.block_count, 4); node_config.peering_port = nano::get_available_port (); auto & node2 = *system.add_node (node_config); - node2.process (*send1); - node2.process (*open1); - node2.process (*send2); + ASSERT_EQ (nano::process_result::progress, node2.process (*send1).code); + ASSERT_EQ (nano::process_result::progress, node2.process (*open1).code); + ASSERT_EQ (nano::process_result::progress, node2.process (*send2).code); system.wallet (1)->insert_adhoc (key1.prv); node2.block_processor.flush (); ASSERT_EQ (node2.ledger.cache.block_count, 4); - node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ()); + node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); node1.scheduler.flush (); auto election = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election); ASSERT_EQ (1, election->blocks ().size ()); - auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, send1)); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); - auto vote2 (std::make_shared (key1.pub, key1.prv, std::numeric_limits::max (), send1)); + auto vote2 (std::make_shared (key1.pub, key1.prv, nano::vote::timestamp_max, nano::vote::duration_max, send1)); auto channel = node1.network.find_channel (node2.network.endpoint ()); ASSERT_NE (channel, nullptr); ASSERT_TIMELY (10s, !node1.rep_crawler.response (channel, vote2)); diff --git a/nano/core_test/election_scheduler.cpp b/nano/core_test/election_scheduler.cpp index cc7afde3eb..9b0ed00261 100644 --- a/nano/core_test/election_scheduler.cpp +++ b/nano/core_test/election_scheduler.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include @@ -18,16 +18,16 @@ TEST (election_scheduler, activate_one_timely) nano::system system{ 1 }; nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1); - system.nodes[0]->scheduler.activate (nano::dev_genesis_key.pub, system.nodes[0]->store.tx_begin_read ()); + system.nodes[0]->scheduler.activate (nano::dev::genesis_key.pub, system.nodes[0]->store.tx_begin_read ()); ASSERT_TIMELY (1s, system.nodes[0]->active.election (send1->qualified_root ())); } @@ -36,16 +36,16 @@ TEST (election_scheduler, activate_one_flush) nano::system system{ 1 }; nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); system.nodes[0]->ledger.process (system.nodes[0]->store.tx_begin_write (), *send1); - system.nodes[0]->scheduler.activate (nano::dev_genesis_key.pub, system.nodes[0]->store.tx_begin_read ()); + system.nodes[0]->scheduler.activate (nano::dev::genesis_key.pub, system.nodes[0]->store.tx_begin_read ()); system.nodes[0]->scheduler.flush (); ASSERT_NE (nullptr, system.nodes[0]->active.election (send1->qualified_root ())); } @@ -61,13 +61,13 @@ TEST (election_scheduler, no_vacancy) // Activating accounts depends on confirmed dependencies. First, prepare 2 accounts auto send = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .link (key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto receive = builder.make_block () .account (key.pub) @@ -87,12 +87,12 @@ TEST (election_scheduler, no_vacancy) // Second, process two eligble transactions auto block0 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send->hash ()) - .representative (nano::dev_genesis_key.pub) - .link (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) + .link (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) .build_shared (); auto block1 = builder.make_block () @@ -106,7 +106,7 @@ TEST (election_scheduler, no_vacancy) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.process (*block0).code); ASSERT_EQ (nano::process_result::progress, node.process (*block1).code); - node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ()); + node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); // There is vacancy so it should be inserted ASSERT_TIMELY (1s, node.active.size () == 1); node.scheduler.activate (key.pub, node.store.tx_begin_read ()); @@ -134,16 +134,16 @@ TEST (election_scheduler, flush_vacancy) nano::keypair key; auto send = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .link (key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.process (*send).code); - node.scheduler.activate (nano::dev_genesis_key.pub, node.store.tx_begin_read ()); + node.scheduler.activate (nano::dev::genesis_key.pub, node.store.tx_begin_read ()); // Ensure this call does not block, even though no elections can be activated. node.scheduler.flush (); ASSERT_EQ (0, node.active.size ()); diff --git a/nano/core_test/fakes/work_peer.hpp b/nano/core_test/fakes/work_peer.hpp index aa874bec5e..0643aff8d4 100644 --- a/nano/core_test/fakes/work_peer.hpp +++ b/nano/core_test/fakes/work_peer.hpp @@ -32,7 +32,7 @@ enum class work_peer_type class work_peer_connection : public std::enable_shared_from_this { - const std::string generic_error = "Unable to parse JSON"; + std::string const generic_error = "Unable to parse JSON"; public: work_peer_connection (asio::io_context & ioc_a, work_peer_type const type_a, nano::work_version const version_a, nano::work_pool & pool_a, std::function on_generation_a, std::function on_cancel_a) : @@ -141,23 +141,21 @@ class work_peer_connection : public std::enable_shared_from_this work_a) { + auto request_difficulty = work_pool.network_constants.work.threshold_base (version); + work_pool.generate (version, hash, request_difficulty, [this_l = shared_from_this (), hash] (boost::optional work_a) { auto result = work_a.value_or (0); - auto result_difficulty (nano::work_difficulty (this_l->version, hash, result)); - static nano::network_params params; + auto result_difficulty (this_l->work_pool.network_constants.work.difficulty (this_l->version, hash, result)); ptree::ptree message_l; message_l.put ("work", nano::to_string_hex (result)); message_l.put ("difficulty", nano::to_string_hex (result_difficulty)); - message_l.put ("multiplier", nano::to_string (nano::difficulty::to_multiplier (result_difficulty, nano::work_threshold_base (this_l->version)))); + message_l.put ("multiplier", nano::to_string (nano::difficulty::to_multiplier (result_difficulty, this_l->work_pool.network_constants.work.threshold_base (this_l->version)))); message_l.put ("hash", hash.to_string ()); std::stringstream ostream; ptree::write_json (ostream, message_l); beast::ostream (this_l->response.body ()) << ostream.str (); // Delay response by 500ms as a slow peer, immediate async call for a good peer this_l->timer.expires_from_now (boost::posix_time::milliseconds (this_l->type == work_peer_type::slow ? 500 : 0)); - this_l->timer.async_wait ([this_l, result] (const boost::system::error_code & ec) { + this_l->timer.async_wait ([this_l, result] (boost::system::error_code const & ec) { if (this_l->on_generation) { this_l->on_generation (result != 0); diff --git a/nano/core_test/frontiers_confirmation.cpp b/nano/core_test/frontiers_confirmation.cpp index a3f8efa6b9..01bace06a8 100644 --- a/nano/core_test/frontiers_confirmation.cpp +++ b/nano/core_test/frontiers_confirmation.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include @@ -20,29 +20,29 @@ TEST (frontiers_confirmation, prioritize_frontiers) nano::keypair key2; nano::keypair key3; nano::keypair key4; - nano::block_hash latest1 (node->latest (nano::dev_genesis_key.pub)); + nano::block_hash latest1 (node->latest (nano::dev::genesis_key.pub)); // Send different numbers of blocks all accounts - nano::send_block send1 (latest1, key1.pub, node->config.online_weight_minimum.number () + 10000, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest1)); - nano::send_block send2 (send1.hash (), key1.pub, node->config.online_weight_minimum.number () + 8500, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1.hash ())); - nano::send_block send3 (send2.hash (), key1.pub, node->config.online_weight_minimum.number () + 8000, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send2.hash ())); - nano::send_block send4 (send3.hash (), key2.pub, node->config.online_weight_minimum.number () + 7500, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send3.hash ())); - nano::send_block send5 (send4.hash (), key3.pub, node->config.online_weight_minimum.number () + 6500, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send4.hash ())); - nano::send_block send6 (send5.hash (), key4.pub, node->config.online_weight_minimum.number () + 6000, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send5.hash ())); + nano::send_block send1 (latest1, key1.pub, node->config.online_weight_minimum.number () + 10000, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1)); + nano::send_block send2 (send1.hash (), key1.pub, node->config.online_weight_minimum.number () + 8500, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ())); + nano::send_block send3 (send2.hash (), key1.pub, node->config.online_weight_minimum.number () + 8000, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2.hash ())); + nano::send_block send4 (send3.hash (), key2.pub, node->config.online_weight_minimum.number () + 7500, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3.hash ())); + nano::send_block send5 (send4.hash (), key3.pub, node->config.online_weight_minimum.number () + 6500, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send4.hash ())); + nano::send_block send6 (send5.hash (), key4.pub, node->config.online_weight_minimum.number () + 6000, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send5.hash ())); // Open all accounts and add other sends to get different uncemented counts (as well as some which are the same) - nano::open_block open1 (send1.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); - nano::send_block send7 (open1.hash (), nano::dev_genesis_key.pub, 500, key1.prv, key1.pub, *system.work.generate (open1.hash ())); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); + nano::send_block send7 (open1.hash (), nano::dev::genesis_key.pub, 500, key1.prv, key1.pub, *system.work.generate (open1.hash ())); - nano::open_block open2 (send4.hash (), nano::genesis_account, key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); + nano::open_block open2 (send4.hash (), nano::dev::genesis->account (), key2.pub, key2.prv, key2.pub, *system.work.generate (key2.pub)); - nano::open_block open3 (send5.hash (), nano::genesis_account, key3.pub, key3.prv, key3.pub, *system.work.generate (key3.pub)); - nano::send_block send8 (open3.hash (), nano::dev_genesis_key.pub, 500, key3.prv, key3.pub, *system.work.generate (open3.hash ())); - nano::send_block send9 (send8.hash (), nano::dev_genesis_key.pub, 200, key3.prv, key3.pub, *system.work.generate (send8.hash ())); + nano::open_block open3 (send5.hash (), nano::dev::genesis->account (), key3.pub, key3.prv, key3.pub, *system.work.generate (key3.pub)); + nano::send_block send8 (open3.hash (), nano::dev::genesis_key.pub, 500, key3.prv, key3.pub, *system.work.generate (open3.hash ())); + nano::send_block send9 (send8.hash (), nano::dev::genesis_key.pub, 200, key3.prv, key3.pub, *system.work.generate (send8.hash ())); - nano::open_block open4 (send6.hash (), nano::genesis_account, key4.pub, key4.prv, key4.pub, *system.work.generate (key4.pub)); - nano::send_block send10 (open4.hash (), nano::dev_genesis_key.pub, 500, key4.prv, key4.pub, *system.work.generate (open4.hash ())); - nano::send_block send11 (send10.hash (), nano::dev_genesis_key.pub, 200, key4.prv, key4.pub, *system.work.generate (send10.hash ())); + nano::open_block open4 (send6.hash (), nano::dev::genesis->account (), key4.pub, key4.prv, key4.pub, *system.work.generate (key4.pub)); + nano::send_block send10 (open4.hash (), nano::dev::genesis_key.pub, 500, key4.prv, key4.pub, *system.work.generate (open4.hash ())); + nano::send_block send11 (send10.hash (), nano::dev::genesis_key.pub, 200, key4.prv, key4.pub, *system.work.generate (send10.hash ())); { auto transaction = node->store.tx_begin_write (); @@ -78,20 +78,20 @@ TEST (frontiers_confirmation, prioritize_frontiers) node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (1), std::chrono::seconds (1)); ASSERT_EQ (node->active.priority_cementable_frontiers_size (), num_accounts); // Check the order of accounts is as expected (greatest number of uncemented blocks at the front). key3 and key4 have the same value, the order is unspecified so check both - std::array desired_order_1{ nano::genesis_account, key3.pub, key4.pub, key1.pub, key2.pub }; - std::array desired_order_2{ nano::genesis_account, key4.pub, key3.pub, key1.pub, key2.pub }; + std::array desired_order_1{ nano::dev::genesis->account (), key3.pub, key4.pub, key1.pub, key2.pub }; + std::array desired_order_2{ nano::dev::genesis->account (), key4.pub, key3.pub, key1.pub, key2.pub }; ASSERT_TRUE (priority_orders_match (node->active.priority_cementable_frontiers, desired_order_1) || priority_orders_match (node->active.priority_cementable_frontiers, desired_order_2)); } { // Add some to the local node wallets and check ordering of both containers - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key1.prv); system.wallet (0)->insert_adhoc (key2.prv); node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (1), std::chrono::seconds (1)); ASSERT_EQ (node->active.priority_cementable_frontiers_size (), num_accounts - 3); ASSERT_EQ (node->active.priority_wallet_cementable_frontiers_size (), num_accounts - 2); - std::array local_desired_order{ nano::genesis_account, key1.pub, key2.pub }; + std::array local_desired_order{ nano::dev::genesis->account (), key1.pub, key2.pub }; ASSERT_TRUE (priority_orders_match (node->active.priority_wallet_cementable_frontiers, local_desired_order)); std::array desired_order_1{ key3.pub, key4.pub }; std::array desired_order_2{ key4.pub, key3.pub }; @@ -105,18 +105,18 @@ TEST (frontiers_confirmation, prioritize_frontiers) node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (1), std::chrono::seconds (1)); ASSERT_EQ (node->active.priority_cementable_frontiers_size (), 0); ASSERT_EQ (node->active.priority_wallet_cementable_frontiers_size (), num_accounts); - std::array desired_order_1{ nano::genesis_account, key3.pub, key4.pub, key1.pub, key2.pub }; - std::array desired_order_2{ nano::genesis_account, key4.pub, key3.pub, key1.pub, key2.pub }; + std::array desired_order_1{ nano::dev::genesis->account (), key3.pub, key4.pub, key1.pub, key2.pub }; + std::array desired_order_2{ nano::dev::genesis->account (), key4.pub, key3.pub, key1.pub, key2.pub }; ASSERT_TRUE (priority_orders_match (node->active.priority_wallet_cementable_frontiers, desired_order_1) || priority_orders_match (node->active.priority_wallet_cementable_frontiers, desired_order_2)); } // Check that accounts which already exist have their order modified when the uncemented count changes. - nano::send_block send12 (send9.hash (), nano::dev_genesis_key.pub, 100, key3.prv, key3.pub, *system.work.generate (send9.hash ())); - nano::send_block send13 (send12.hash (), nano::dev_genesis_key.pub, 90, key3.prv, key3.pub, *system.work.generate (send12.hash ())); - nano::send_block send14 (send13.hash (), nano::dev_genesis_key.pub, 80, key3.prv, key3.pub, *system.work.generate (send13.hash ())); - nano::send_block send15 (send14.hash (), nano::dev_genesis_key.pub, 70, key3.prv, key3.pub, *system.work.generate (send14.hash ())); - nano::send_block send16 (send15.hash (), nano::dev_genesis_key.pub, 60, key3.prv, key3.pub, *system.work.generate (send15.hash ())); - nano::send_block send17 (send16.hash (), nano::dev_genesis_key.pub, 50, key3.prv, key3.pub, *system.work.generate (send16.hash ())); + nano::send_block send12 (send9.hash (), nano::dev::genesis_key.pub, 100, key3.prv, key3.pub, *system.work.generate (send9.hash ())); + nano::send_block send13 (send12.hash (), nano::dev::genesis_key.pub, 90, key3.prv, key3.pub, *system.work.generate (send12.hash ())); + nano::send_block send14 (send13.hash (), nano::dev::genesis_key.pub, 80, key3.prv, key3.pub, *system.work.generate (send13.hash ())); + nano::send_block send15 (send14.hash (), nano::dev::genesis_key.pub, 70, key3.prv, key3.pub, *system.work.generate (send14.hash ())); + nano::send_block send16 (send15.hash (), nano::dev::genesis_key.pub, 60, key3.prv, key3.pub, *system.work.generate (send15.hash ())); + nano::send_block send17 (send16.hash (), nano::dev::genesis_key.pub, 50, key3.prv, key3.pub, *system.work.generate (send16.hash ())); { auto transaction = node->store.tx_begin_write (); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send12).code); @@ -128,7 +128,7 @@ TEST (frontiers_confirmation, prioritize_frontiers) } transaction.refresh (); node->active.prioritize_frontiers_for_confirmation (transaction, std::chrono::seconds (1), std::chrono::seconds (1)); - ASSERT_TRUE (priority_orders_match (node->active.priority_wallet_cementable_frontiers, std::array{ key3.pub, nano::genesis_account, key4.pub, key1.pub, key2.pub })); + ASSERT_TRUE (priority_orders_match (node->active.priority_wallet_cementable_frontiers, std::array{ key3.pub, nano::dev::genesis->account (), key4.pub, key1.pub, key2.pub })); uint64_t election_count = 0; node->active.confirm_prioritized_frontiers (transaction, 100, election_count); @@ -159,11 +159,11 @@ TEST (frontiers_confirmation, prioritize_frontiers_max_optimistic_elections) for (auto i = 0; i < max_optimistic_election_count * 2; ++i) { auto transaction = node->store.tx_begin_write (); - auto latest = node->latest (nano::genesis_account); + auto latest = node->latest (nano::dev::genesis->account ()); nano::keypair key; - nano::send_block send (latest, key.pub, node->config.online_weight_minimum.number () + 10000, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); + nano::send_block send (latest, key.pub, node->config.online_weight_minimum.number () + 10000, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); - nano::open_block open (send.hash (), nano::genesis_account, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); + nano::open_block open (send.hash (), nano::dev::genesis->account (), key.pub, key.prv, key.pub, *system.work.generate (key.pub)); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open).code); } @@ -210,7 +210,6 @@ TEST (frontiers_confirmation, expired_optimistic_elections_removal) TEST (frontiers_confirmation, mode) { - nano::genesis genesis; nano::keypair key; nano::node_flags node_flags; // Always mode @@ -219,7 +218,7 @@ TEST (frontiers_confirmation, mode) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::always; auto node = system.add_node (node_config, node_flags); - nano::state_block send (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node->work_generate_blocking (genesis.hash ())); + nano::state_block send (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (nano::dev::genesis->hash ())); { auto transaction = node->store.tx_begin_write (); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); @@ -232,7 +231,7 @@ TEST (frontiers_confirmation, mode) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::automatic; auto node = system.add_node (node_config, node_flags); - nano::state_block send (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node->work_generate_blocking (genesis.hash ())); + nano::state_block send (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (nano::dev::genesis->hash ())); { auto transaction = node->store.tx_begin_write (); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); @@ -245,12 +244,12 @@ TEST (frontiers_confirmation, mode) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config, node_flags); - nano::state_block send (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node->work_generate_blocking (genesis.hash ())); + nano::state_block send (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (nano::dev::genesis->hash ())); { auto transaction = node->store.tx_begin_write (); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); } - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); std::this_thread::sleep_for (std::chrono::seconds (1)); ASSERT_EQ (0, node->active.size ()); } diff --git a/nano/core_test/gap_cache.cpp b/nano/core_test/gap_cache.cpp index d87a071220..3bd70273e8 100644 --- a/nano/core_test/gap_cache.cpp +++ b/nano/core_test/gap_cache.cpp @@ -1,4 +1,4 @@ -#include +#include #include #include @@ -65,12 +65,12 @@ TEST (gap_cache, gap_bootstrap) auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); - nano::block_hash latest (node1.latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node1.latest (nano::dev::genesis_key.pub)); nano::keypair key; - auto send (std::make_shared (latest, key.pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest))); - node1.process (*send); - ASSERT_EQ (nano::genesis_amount - 100, node1.balance (nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, node2.balance (nano::genesis_account)); + auto send (std::make_shared (latest, key.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest))); + ASSERT_EQ (nano::process_result::progress, node1.process (*send).code); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, node1.balance (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, node2.balance (nano::dev::genesis->account ())); // Confirm send block, allowing voting on the upcoming block node1.block_confirm (send); auto election = node1.active.election (send->qualified_root ()); @@ -78,12 +78,12 @@ TEST (gap_cache, gap_bootstrap) election->force_confirm (); ASSERT_TIMELY (2s, node1.block_confirmed (send->hash ())); node1.active.erase (*send); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto latest_block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 100)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto latest_block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 100)); ASSERT_NE (nullptr, latest_block); - ASSERT_EQ (nano::genesis_amount - 200, node1.balance (nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, node2.balance (nano::genesis_account)); - ASSERT_TIMELY (10s, node2.balance (nano::genesis_account) == nano::genesis_amount - 200); + ASSERT_EQ (nano::dev::constants.genesis_amount - 200, node1.balance (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, node2.balance (nano::dev::genesis->account ())); + ASSERT_TIMELY (10s, node2.balance (nano::dev::genesis->account ()) == nano::dev::constants.genesis_amount - 200); } TEST (gap_cache, two_dependencies) @@ -91,9 +91,8 @@ TEST (gap_cache, two_dependencies) nano::system system (1); auto & node1 (*system.nodes[0]); nano::keypair key; - nano::genesis genesis; - auto send1 (std::make_shared (genesis.hash (), key.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (genesis.hash ()))); - auto send2 (std::make_shared (send1->hash (), key.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ()))); + auto send1 (std::make_shared (nano::dev::genesis->hash (), key.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); + auto send2 (std::make_shared (send1->hash (), key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()))); auto open (std::make_shared (send1->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub))); ASSERT_EQ (0, node1.gap_cache.size ()); node1.block_processor.add (send2, nano::seconds_since_epoch ()); @@ -106,7 +105,7 @@ TEST (gap_cache, two_dependencies) node1.block_processor.flush (); ASSERT_EQ (0, node1.gap_cache.size ()); auto transaction (node1.store.tx_begin_read ()); - ASSERT_TRUE (node1.store.block_exists (transaction, send1->hash ())); - ASSERT_TRUE (node1.store.block_exists (transaction, send2->hash ())); - ASSERT_TRUE (node1.store.block_exists (transaction, open->hash ())); + ASSERT_TRUE (node1.store.block.exists (transaction, send1->hash ())); + ASSERT_TRUE (node1.store.block.exists (transaction, send2->hash ())); + ASSERT_TRUE (node1.store.block.exists (transaction, open->hash ())); } diff --git a/nano/core_test/ipc.cpp b/nano/core_test/ipc.cpp index 012a2e5632..a12ce3e7cf 100644 --- a/nano/core_test/ipc.cpp +++ b/nano/core_test/ipc.cpp @@ -2,8 +2,8 @@ #include #include #include -#include #include +#include #include #include diff --git a/nano/core_test/ledger.cpp b/nano/core_test/ledger.cpp index cca4cf7e48..44e278a526 100644 --- a/nano/core_test/ledger.cpp +++ b/nano/core_test/ledger.cpp @@ -2,7 +2,7 @@ #include #include #include -#include +#include #include #include @@ -12,26 +12,26 @@ using namespace std::chrono_literals; // Init returns an error if it can't open files at the path TEST (ledger, store_error) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; } nano::logger_mt logger; - nano::mdb_store store (logger, boost::filesystem::path ("///")); + nano::mdb_store store (logger, boost::filesystem::path ("///"), nano::dev::constants); ASSERT_TRUE (store.init_error ()); nano::stat stats; - nano::ledger ledger (store, stats); + nano::ledger ledger (store, stats, nano::dev::constants); } // Ledger can be initialized and returns a basic query for an empty account TEST (ledger, empty) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); nano::account account; auto transaction (store->tx_begin_read ()); auto balance (ledger.account_balance (transaction, account)); @@ -42,90 +42,76 @@ TEST (ledger, empty) TEST (ledger, genesis_balance) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - auto balance (ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, balance); - auto amount (ledger.amount (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, amount); + store->initialize (transaction, ledger.cache); + auto balance (ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, balance); + auto amount (ledger.amount (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, amount); nano::account_info info; - ASSERT_FALSE (store->account_get (transaction, nano::genesis_account, info)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis->account (), info)); ASSERT_EQ (1, ledger.cache.account_count); // Frontier time should have been updated when genesis balance was added ASSERT_GE (nano::seconds_since_epoch (), info.modified); ASSERT_LT (nano::seconds_since_epoch () - info.modified, 10); // Genesis block should be confirmed by default nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store->confirmation_height_get (transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (store->confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 1); - ASSERT_EQ (confirmation_height_info.frontier, genesis.hash ()); -} - -// All nodes in the system should agree on the genesis balance -TEST (system, system_genesis) -{ - nano::system system (2); - for (auto & i : system.nodes) - { - auto transaction (i->store.tx_begin_read ()); - ASSERT_EQ (nano::genesis_amount, i->ledger.account_balance (transaction, nano::genesis_account)); - } + ASSERT_EQ (confirmation_height_info.frontier, nano::dev::genesis->hash ()); } TEST (ledger, process_modifies_sideband) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; - store->initialize (store->tx_begin_write (), genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::ledger ledger (*store, stats, nano::dev::constants); + store->initialize (store->tx_begin_write (), ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (store->tx_begin_write (), send1).code); - ASSERT_EQ (send1.sideband ().timestamp, store->block_get (store->tx_begin_read (), send1.hash ())->sideband ().timestamp); + ASSERT_EQ (send1.sideband ().timestamp, store->block.get (store->tx_begin_read (), send1.hash ())->sideband ().timestamp); } // Create a send block and publish it. TEST (ledger, process_send) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - nano::genesis genesis; - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::account_info info1; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info1)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1)); nano::keypair key2; - nano::send_block send (info1.head, key2.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head)); + nano::send_block send (info1.head, key2.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head)); nano::block_hash hash1 (send.hash ()); - ASSERT_EQ (nano::dev_genesis_key.pub, store->frontier_get (transaction, info1.head)); + ASSERT_EQ (nano::dev::genesis_key.pub, store->frontier.get (transaction, info1.head)); ASSERT_EQ (1, info1.block_count); // This was a valid block, it should progress. auto return1 (ledger.process (transaction, send)); - ASSERT_EQ (nano::dev_genesis_key.pub, send.sideband ().account); + ASSERT_EQ (nano::dev::genesis_key.pub, send.sideband ().account); ASSERT_EQ (2, send.sideband ().height); - ASSERT_EQ (nano::genesis_amount - 50, ledger.amount (transaction, hash1)); - ASSERT_TRUE (store->frontier_get (transaction, info1.head).is_zero ()); - ASSERT_EQ (nano::dev_genesis_key.pub, store->frontier_get (transaction, hash1)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash1)); + ASSERT_TRUE (store->frontier.get (transaction, info1.head).is_zero ()); + ASSERT_EQ (nano::dev::genesis_key.pub, store->frontier.get (transaction, hash1)); ASSERT_EQ (nano::process_result::progress, return1.code); - ASSERT_EQ (nano::dev_genesis_key.pub, store->block_account_calculated (send)); - ASSERT_EQ (50, ledger.account_balance (transaction, nano::dev_genesis_key.pub)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.account_pending (transaction, key2.pub)); + ASSERT_EQ (nano::dev::genesis_key.pub, store->block.account_calculated (send)); + ASSERT_EQ (50, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_pending (transaction, key2.pub)); nano::account_info info2; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info2)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info2)); ASSERT_EQ (2, info2.block_count); - auto latest6 (store->block_get (transaction, info2.head)); + auto latest6 (store->block.get (transaction, info2.head)); ASSERT_NE (nullptr, latest6); auto latest7 (dynamic_cast (latest6.get ())); ASSERT_NE (nullptr, latest7); @@ -137,77 +123,76 @@ TEST (ledger, process_send) auto return2 (ledger.process (transaction, open)); ASSERT_EQ (nano::process_result::progress, return2.code); ASSERT_EQ (key2.pub, open.sideband ().account); - ASSERT_EQ (nano::genesis_amount - 50, open.sideband ().balance.number ()); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, open.sideband ().balance.number ()); ASSERT_EQ (1, open.sideband ().height); - ASSERT_EQ (nano::genesis_amount - 50, ledger.amount (transaction, hash2)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash2)); ASSERT_EQ (nano::process_result::progress, return2.code); - ASSERT_EQ (key2.pub, store->block_account_calculated (open)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.amount (transaction, hash2)); - ASSERT_EQ (key2.pub, store->frontier_get (transaction, hash2)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); + ASSERT_EQ (key2.pub, store->block.account_calculated (open)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash2)); + ASSERT_EQ (key2.pub, store->frontier.get (transaction, hash2)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); ASSERT_EQ (0, ledger.account_pending (transaction, key2.pub)); - ASSERT_EQ (50, ledger.weight (nano::dev_genesis_key.pub)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (key2.pub)); + ASSERT_EQ (50, ledger.weight (nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.weight (key2.pub)); nano::account_info info3; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info3)); - auto latest2 (store->block_get (transaction, info3.head)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info3)); + auto latest2 (store->block.get (transaction, info3.head)); ASSERT_NE (nullptr, latest2); auto latest3 (dynamic_cast (latest2.get ())); ASSERT_NE (nullptr, latest3); ASSERT_EQ (send, *latest3); nano::account_info info4; - ASSERT_FALSE (store->account_get (transaction, key2.pub, info4)); - auto latest4 (store->block_get (transaction, info4.head)); + ASSERT_FALSE (store->account.get (transaction, key2.pub, info4)); + auto latest4 (store->block.get (transaction, info4.head)); ASSERT_NE (nullptr, latest4); auto latest5 (dynamic_cast (latest4.get ())); ASSERT_NE (nullptr, latest5); ASSERT_EQ (open, *latest5); ASSERT_FALSE (ledger.rollback (transaction, hash2)); - ASSERT_TRUE (store->frontier_get (transaction, hash2).is_zero ()); + ASSERT_TRUE (store->frontier.get (transaction, hash2).is_zero ()); nano::account_info info5; - ASSERT_TRUE (ledger.store.account_get (transaction, key2.pub, info5)); + ASSERT_TRUE (ledger.store.account.get (transaction, key2.pub, info5)); nano::pending_info pending1; - ASSERT_FALSE (ledger.store.pending_get (transaction, nano::pending_key (key2.pub, hash1), pending1)); - ASSERT_EQ (nano::dev_genesis_key.pub, pending1.source); - ASSERT_EQ (nano::genesis_amount - 50, pending1.amount.number ()); + ASSERT_FALSE (ledger.store.pending.get (transaction, nano::pending_key (key2.pub, hash1), pending1)); + ASSERT_EQ (nano::dev::genesis_key.pub, pending1.source); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, pending1.amount.number ()); ASSERT_EQ (0, ledger.account_balance (transaction, key2.pub)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.account_pending (transaction, key2.pub)); - ASSERT_EQ (50, ledger.account_balance (transaction, nano::dev_genesis_key.pub)); - ASSERT_EQ (50, ledger.weight (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_pending (transaction, key2.pub)); + ASSERT_EQ (50, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); + ASSERT_EQ (50, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.weight (key2.pub)); nano::account_info info6; - ASSERT_FALSE (ledger.store.account_get (transaction, nano::dev_genesis_key.pub, info6)); + ASSERT_FALSE (ledger.store.account.get (transaction, nano::dev::genesis_key.pub, info6)); ASSERT_EQ (hash1, info6.head); ASSERT_FALSE (ledger.rollback (transaction, info6.head)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::dev_genesis_key.pub)); - ASSERT_EQ (nano::dev_genesis_key.pub, store->frontier_get (transaction, info1.head)); - ASSERT_TRUE (store->frontier_get (transaction, hash1).is_zero ()); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::genesis_key.pub, store->frontier.get (transaction, info1.head)); + ASSERT_TRUE (store->frontier.get (transaction, hash1).is_zero ()); nano::account_info info7; - ASSERT_FALSE (ledger.store.account_get (transaction, nano::dev_genesis_key.pub, info7)); + ASSERT_FALSE (ledger.store.account.get (transaction, nano::dev::genesis_key.pub, info7)); ASSERT_EQ (1, info7.block_count); ASSERT_EQ (info1.head, info7.head); nano::pending_info pending2; - ASSERT_TRUE (ledger.store.pending_get (transaction, nano::pending_key (key2.pub, hash1), pending2)); - ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::dev_genesis_key.pub)); + ASSERT_TRUE (ledger.store.pending.get (transaction, nano::pending_key (key2.pub, hash1), pending2)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.account_pending (transaction, key2.pub)); - ASSERT_EQ (store->account_count (transaction), ledger.cache.account_count); + ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } TEST (ledger, process_receive) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::account_info info1; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info1)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1)); nano::keypair key2; - nano::send_block send (info1.head, key2.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head)); + nano::send_block send (info1.head, key2.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head)); nano::block_hash hash1 (send.hash ()); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); nano::keypair key3; @@ -215,63 +200,62 @@ TEST (ledger, process_receive) nano::block_hash hash2 (open.hash ()); auto return1 (ledger.process (transaction, open)); ASSERT_EQ (nano::process_result::progress, return1.code); - ASSERT_EQ (key2.pub, store->block_account_calculated (open)); + ASSERT_EQ (key2.pub, store->block.account_calculated (open)); ASSERT_EQ (key2.pub, open.sideband ().account); - ASSERT_EQ (nano::genesis_amount - 50, open.sideband ().balance.number ()); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, open.sideband ().balance.number ()); ASSERT_EQ (1, open.sideband ().height); - ASSERT_EQ (nano::genesis_amount - 50, ledger.amount (transaction, hash2)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (key3.pub)); - nano::send_block send2 (hash1, key2.pub, 25, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (hash1)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.amount (transaction, hash2)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.weight (key3.pub)); + nano::send_block send2 (hash1, key2.pub, 25, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (hash1)); nano::block_hash hash3 (send2.hash ()); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); nano::receive_block receive (hash2, hash3, key2.prv, key2.pub, *pool.generate (hash2)); auto hash4 (receive.hash ()); - ASSERT_EQ (key2.pub, store->frontier_get (transaction, hash2)); + ASSERT_EQ (key2.pub, store->frontier.get (transaction, hash2)); auto return2 (ledger.process (transaction, receive)); ASSERT_EQ (key2.pub, receive.sideband ().account); - ASSERT_EQ (nano::genesis_amount - 25, receive.sideband ().balance.number ()); + ASSERT_EQ (nano::dev::constants.genesis_amount - 25, receive.sideband ().balance.number ()); ASSERT_EQ (2, receive.sideband ().height); ASSERT_EQ (25, ledger.amount (transaction, hash4)); - ASSERT_TRUE (store->frontier_get (transaction, hash2).is_zero ()); - ASSERT_EQ (key2.pub, store->frontier_get (transaction, hash4)); + ASSERT_TRUE (store->frontier.get (transaction, hash2).is_zero ()); + ASSERT_EQ (key2.pub, store->frontier.get (transaction, hash4)); ASSERT_EQ (nano::process_result::progress, return2.code); - ASSERT_EQ (key2.pub, store->block_account_calculated (receive)); + ASSERT_EQ (key2.pub, store->block.account_calculated (receive)); ASSERT_EQ (hash4, ledger.latest (transaction, key2.pub)); - ASSERT_EQ (25, ledger.account_balance (transaction, nano::dev_genesis_key.pub)); + ASSERT_EQ (25, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.account_pending (transaction, key2.pub)); - ASSERT_EQ (nano::genesis_amount - 25, ledger.account_balance (transaction, key2.pub)); - ASSERT_EQ (nano::genesis_amount - 25, ledger.weight (key3.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 25, ledger.account_balance (transaction, key2.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 25, ledger.weight (key3.pub)); ASSERT_FALSE (ledger.rollback (transaction, hash4)); - ASSERT_TRUE (store->block_successor (transaction, hash2).is_zero ()); - ASSERT_EQ (key2.pub, store->frontier_get (transaction, hash2)); - ASSERT_TRUE (store->frontier_get (transaction, hash4).is_zero ()); - ASSERT_EQ (25, ledger.account_balance (transaction, nano::dev_genesis_key.pub)); + ASSERT_TRUE (store->block.successor (transaction, hash2).is_zero ()); + ASSERT_EQ (key2.pub, store->frontier.get (transaction, hash2)); + ASSERT_TRUE (store->frontier.get (transaction, hash4).is_zero ()); + ASSERT_EQ (25, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); ASSERT_EQ (25, ledger.account_pending (transaction, key2.pub)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (key3.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.weight (key3.pub)); ASSERT_EQ (hash2, ledger.latest (transaction, key2.pub)); nano::pending_info pending1; - ASSERT_FALSE (ledger.store.pending_get (transaction, nano::pending_key (key2.pub, hash3), pending1)); - ASSERT_EQ (nano::dev_genesis_key.pub, pending1.source); + ASSERT_FALSE (ledger.store.pending.get (transaction, nano::pending_key (key2.pub, hash3), pending1)); + ASSERT_EQ (nano::dev::genesis_key.pub, pending1.source); ASSERT_EQ (25, pending1.amount.number ()); - ASSERT_EQ (store->account_count (transaction), ledger.cache.account_count); + ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } TEST (ledger, rollback_receiver) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::account_info info1; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info1)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1)); nano::keypair key2; - nano::send_block send (info1.head, key2.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head)); + nano::send_block send (info1.head, key2.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head)); nano::block_hash hash1 (send.hash ()); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); nano::keypair key3; @@ -279,92 +263,90 @@ TEST (ledger, rollback_receiver) nano::block_hash hash2 (open.hash ()); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); ASSERT_EQ (hash2, ledger.latest (transaction, key2.pub)); - ASSERT_EQ (50, ledger.account_balance (transaction, nano::dev_genesis_key.pub)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); - ASSERT_EQ (50, ledger.weight (nano::dev_genesis_key.pub)); + ASSERT_EQ (50, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.account_balance (transaction, key2.pub)); + ASSERT_EQ (50, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.weight (key2.pub)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (key3.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.weight (key3.pub)); ASSERT_FALSE (ledger.rollback (transaction, hash1)); - ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.account_balance (transaction, key2.pub)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.weight (key2.pub)); ASSERT_EQ (0, ledger.weight (key3.pub)); nano::account_info info2; - ASSERT_TRUE (ledger.store.account_get (transaction, key2.pub, info2)); - ASSERT_EQ (store->account_count (transaction), ledger.cache.account_count); + ASSERT_TRUE (ledger.store.account.get (transaction, key2.pub, info2)); + ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); nano::pending_info pending1; - ASSERT_TRUE (ledger.store.pending_get (transaction, nano::pending_key (key2.pub, info2.head), pending1)); + ASSERT_TRUE (ledger.store.pending.get (transaction, nano::pending_key (key2.pub, info2.head), pending1)); } TEST (ledger, rollback_representation) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key5; - nano::change_block change1 (genesis.hash (), key5.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::change_block change1 (nano::dev::genesis->hash (), key5.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change1).code); nano::keypair key3; - nano::change_block change2 (change1.hash (), key3.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (change1.hash ())); + nano::change_block change2 (change1.hash (), key3.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (change1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change2).code); nano::keypair key2; - nano::send_block send1 (change2.hash (), key2.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (change2.hash ())); + nano::send_block send1 (change2.hash (), key2.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (change2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); nano::keypair key4; nano::open_block open (send1.hash (), key4.pub, key2.pub, key2.prv, key2.pub, *pool.generate (key2.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); - nano::send_block send2 (send1.hash (), key2.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::send_block send2 (send1.hash (), key2.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); nano::receive_block receive1 (open.hash (), send2.hash (), key2.prv, key2.pub, *pool.generate (open.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); ASSERT_EQ (1, ledger.weight (key3.pub)); - ASSERT_EQ (nano::genesis_amount - 1, ledger.weight (key4.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 1, ledger.weight (key4.pub)); nano::account_info info1; - ASSERT_FALSE (store->account_get (transaction, key2.pub, info1)); + ASSERT_FALSE (store->account.get (transaction, key2.pub, info1)); ASSERT_EQ (key4.pub, info1.representative); ASSERT_FALSE (ledger.rollback (transaction, receive1.hash ())); nano::account_info info2; - ASSERT_FALSE (store->account_get (transaction, key2.pub, info2)); + ASSERT_FALSE (store->account.get (transaction, key2.pub, info2)); ASSERT_EQ (key4.pub, info2.representative); ASSERT_EQ (0, ledger.weight (key2.pub)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (key4.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.weight (key4.pub)); ASSERT_FALSE (ledger.rollback (transaction, open.hash ())); ASSERT_EQ (1, ledger.weight (key3.pub)); ASSERT_EQ (0, ledger.weight (key4.pub)); ledger.rollback (transaction, send1.hash ()); - ASSERT_EQ (nano::genesis_amount, ledger.weight (key3.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (key3.pub)); nano::account_info info3; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info3)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info3)); ASSERT_EQ (key3.pub, info3.representative); ASSERT_FALSE (ledger.rollback (transaction, change2.hash ())); nano::account_info info4; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info4)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info4)); ASSERT_EQ (key5.pub, info4.representative); - ASSERT_EQ (nano::genesis_amount, ledger.weight (key5.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (key5.pub)); ASSERT_EQ (0, ledger.weight (key3.pub)); } TEST (ledger, receive_rollback) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::send_block send (genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::send_block send (nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); - nano::receive_block receive (send.hash (), send.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send.hash ())); + nano::receive_block receive (send.hash (), send.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code); ASSERT_FALSE (ledger.rollback (transaction, receive.hash ())); } @@ -372,18 +354,17 @@ TEST (ledger, receive_rollback) TEST (ledger, process_duplicate) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::account_info info1; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info1)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1)); nano::keypair key2; - nano::send_block send (info1.head, key2.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head)); + nano::send_block send (info1.head, key2.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head)); nano::block_hash hash1 (send.hash ()); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); ASSERT_EQ (nano::process_result::old, ledger.process (transaction, send).code); @@ -395,113 +376,108 @@ TEST (ledger, process_duplicate) TEST (ledger, representative_genesis) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - auto latest (ledger.latest (transaction, nano::dev_genesis_key.pub)); + store->initialize (transaction, ledger.cache); + auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); ASSERT_FALSE (latest.is_zero ()); - ASSERT_EQ (genesis.open->hash (), ledger.representative (transaction, latest)); + ASSERT_EQ (nano::dev::genesis->hash (), ledger.representative (transaction, latest)); } TEST (ledger, weight) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + store->initialize (transaction, ledger.cache); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); } TEST (ledger, representative_change) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); nano::keypair key2; - nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::dev_genesis_key.pub)); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.weight (key2.pub)); nano::account_info info1; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info1)); - nano::change_block block (info1.head, key2.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head)); - ASSERT_EQ (nano::dev_genesis_key.pub, store->frontier_get (transaction, info1.head)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1)); + nano::change_block block (info1.head, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head)); + ASSERT_EQ (nano::dev::genesis_key.pub, store->frontier.get (transaction, info1.head)); auto return1 (ledger.process (transaction, block)); ASSERT_EQ (0, ledger.amount (transaction, block.hash ())); - ASSERT_TRUE (store->frontier_get (transaction, info1.head).is_zero ()); - ASSERT_EQ (nano::dev_genesis_key.pub, store->frontier_get (transaction, block.hash ())); + ASSERT_TRUE (store->frontier.get (transaction, info1.head).is_zero ()); + ASSERT_EQ (nano::dev::genesis_key.pub, store->frontier.get (transaction, block.hash ())); ASSERT_EQ (nano::process_result::progress, return1.code); - ASSERT_EQ (nano::dev_genesis_key.pub, store->block_account_calculated (block)); - ASSERT_EQ (0, ledger.weight (nano::dev_genesis_key.pub)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (key2.pub)); + ASSERT_EQ (nano::dev::genesis_key.pub, store->block.account_calculated (block)); + ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (key2.pub)); nano::account_info info2; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info2)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info2)); ASSERT_EQ (block.hash (), info2.head); ASSERT_FALSE (ledger.rollback (transaction, info2.head)); - ASSERT_EQ (nano::dev_genesis_key.pub, store->frontier_get (transaction, info1.head)); - ASSERT_TRUE (store->frontier_get (transaction, block.hash ()).is_zero ()); + ASSERT_EQ (nano::dev::genesis_key.pub, store->frontier.get (transaction, info1.head)); + ASSERT_TRUE (store->frontier.get (transaction, block.hash ()).is_zero ()); nano::account_info info3; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info3)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info3)); ASSERT_EQ (info1.head, info3.head); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.weight (key2.pub)); } TEST (ledger, send_fork) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); nano::keypair key2; nano::keypair key3; - nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::account_info info1; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info1)); - nano::send_block block (info1.head, key2.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1)); + nano::send_block block (info1.head, key2.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block).code); - nano::send_block block2 (info1.head, key3.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head)); + nano::send_block block2 (info1.head, key3.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head)); ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, block2).code); } TEST (ledger, receive_fork) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); nano::keypair key2; nano::keypair key3; - nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::account_info info1; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info1)); - nano::send_block block (info1.head, key2.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1)); + nano::send_block block (info1.head, key2.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block).code); nano::open_block block2 (block.hash (), key2.pub, key2.pub, key2.prv, key2.pub, *pool.generate (key2.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); nano::change_block block3 (block2.hash (), key3.pub, key2.prv, key2.pub, *pool.generate (block2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code); - nano::send_block block4 (block.hash (), key2.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block.hash ())); + nano::send_block block4 (block.hash (), key2.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block4).code); nano::receive_block block5 (block2.hash (), block4.hash (), key2.prv, key2.pub, *pool.generate (block2.hash ())); ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, block5).code); @@ -510,19 +486,18 @@ TEST (ledger, receive_fork) TEST (ledger, open_fork) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); nano::keypair key2; nano::keypair key3; - nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::account_info info1; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info1)); - nano::send_block block (info1.head, key2.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1)); + nano::send_block block (info1.head, key2.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block).code); nano::open_block block2 (block.hash (), key2.pub, key2.pub, key2.prv, key2.pub, *pool.generate (key2.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); @@ -530,103 +505,6 @@ TEST (ledger, open_fork) ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, block3).code); } -TEST (system, DISABLED_generate_send_existing) -{ - nano::system system (1); - auto & node1 (*system.nodes[0]); - nano::thread_runner runner (system.io_ctx, node1.config.io_threads); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - nano::keypair stake_preserver; - auto send_block (system.wallet (0)->send_action (nano::genesis_account, stake_preserver.pub, nano::genesis_amount / 3 * 2, true)); - nano::account_info info1; - { - auto transaction (node1.store.tx_begin_read ()); - ASSERT_FALSE (node1.store.account_get (transaction, nano::dev_genesis_key.pub, info1)); - } - std::vector accounts; - accounts.push_back (nano::dev_genesis_key.pub); - system.generate_send_existing (node1, accounts); - // Have stake_preserver receive funds after generate_send_existing so it isn't chosen as the destination - { - auto transaction (node1.store.tx_begin_write ()); - auto open_block (std::make_shared (send_block->hash (), nano::genesis_account, stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0)); - node1.work_generate_blocking (*open_block); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code); - } - ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::genesis_account)); - nano::account_info info2; - { - auto transaction (node1.store.tx_begin_read ()); - ASSERT_FALSE (node1.store.account_get (transaction, nano::dev_genesis_key.pub, info2)); - } - ASSERT_NE (info1.head, info2.head); - system.deadline_set (15s); - while (info2.block_count < info1.block_count + 2) - { - ASSERT_NO_ERROR (system.poll ()); - auto transaction (node1.store.tx_begin_read ()); - ASSERT_FALSE (node1.store.account_get (transaction, nano::dev_genesis_key.pub, info2)); - } - ASSERT_EQ (info1.block_count + 2, info2.block_count); - ASSERT_EQ (info2.balance, nano::genesis_amount / 3); - { - auto transaction (node1.store.tx_begin_read ()); - ASSERT_NE (node1.ledger.amount (transaction, info2.head), 0); - } - system.stop (); - runner.join (); -} - -TEST (system, DISABLED_generate_send_new) -{ - nano::system system (1); - auto & node1 (*system.nodes[0]); - nano::thread_runner runner (system.io_ctx, node1.config.io_threads); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - { - auto transaction (node1.store.tx_begin_read ()); - auto iterator1 (node1.store.accounts_begin (transaction)); - ASSERT_NE (node1.store.accounts_end (), iterator1); - ++iterator1; - ASSERT_EQ (node1.store.accounts_end (), iterator1); - } - nano::keypair stake_preserver; - auto send_block (system.wallet (0)->send_action (nano::genesis_account, stake_preserver.pub, nano::genesis_amount / 3 * 2, true)); - { - auto transaction (node1.store.tx_begin_write ()); - auto open_block (std::make_shared (send_block->hash (), nano::genesis_account, stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0)); - node1.work_generate_blocking (*open_block); - ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code); - } - ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::genesis_account)); - std::vector accounts; - accounts.push_back (nano::dev_genesis_key.pub); - // This indirectly waits for online weight to stabilize, required to prevent intermittent failures - ASSERT_TIMELY (5s, node1.wallets.reps ().voting > 0); - system.generate_send_new (node1, accounts); - nano::account new_account (0); - { - auto transaction (node1.wallets.tx_begin_read ()); - auto iterator2 (system.wallet (0)->store.begin (transaction)); - if (iterator2->first != nano::dev_genesis_key.pub) - { - new_account = iterator2->first; - } - ++iterator2; - ASSERT_NE (system.wallet (0)->store.end (), iterator2); - if (iterator2->first != nano::dev_genesis_key.pub) - { - new_account = iterator2->first; - } - ++iterator2; - ASSERT_EQ (system.wallet (0)->store.end (), iterator2); - ASSERT_FALSE (new_account.is_zero ()); - } - ASSERT_TIMELY (10s, node1.balance (new_account) != 0); - system.stop (); - runner.join (); -} - TEST (ledger, representation_changes) { nano::keypair key1; @@ -641,47 +519,46 @@ TEST (ledger, representation_changes) TEST (ledger, representation) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); auto & rep_weights = ledger.cache.rep_weights; - nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - ASSERT_EQ (nano::genesis_amount, rep_weights.representation_get (nano::dev_genesis_key.pub)); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + ASSERT_EQ (nano::dev::constants.genesis_amount, rep_weights.representation_get (nano::dev::genesis_key.pub)); nano::keypair key2; - nano::send_block block1 (genesis.hash (), key2.pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), key2.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); - ASSERT_EQ (nano::genesis_amount - 100, rep_weights.representation_get (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, rep_weights.representation_get (nano::dev::genesis_key.pub)); nano::keypair key3; nano::open_block block2 (block1.hash (), key3.pub, key2.pub, key2.prv, key2.pub, *pool.generate (key2.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); - ASSERT_EQ (nano::genesis_amount - 100, rep_weights.representation_get (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (100, rep_weights.representation_get (key3.pub)); - nano::send_block block3 (block1.hash (), key2.pub, nano::genesis_amount - 200, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ())); + nano::send_block block3 (block1.hash (), key2.pub, nano::dev::constants.genesis_amount - 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code); - ASSERT_EQ (nano::genesis_amount - 200, rep_weights.representation_get (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (100, rep_weights.representation_get (key3.pub)); nano::receive_block block4 (block2.hash (), block3.hash (), key2.prv, key2.pub, *pool.generate (block2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block4).code); - ASSERT_EQ (nano::genesis_amount - 200, rep_weights.representation_get (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (200, rep_weights.representation_get (key3.pub)); nano::keypair key4; nano::change_block block5 (block4.hash (), key4.pub, key2.prv, key2.pub, *pool.generate (block4.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block5).code); - ASSERT_EQ (nano::genesis_amount - 200, rep_weights.representation_get (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); ASSERT_EQ (200, rep_weights.representation_get (key4.pub)); nano::keypair key5; nano::send_block block6 (block5.hash (), key5.pub, 100, key2.prv, key2.pub, *pool.generate (block5.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block6).code); - ASSERT_EQ (nano::genesis_amount - 200, rep_weights.representation_get (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); ASSERT_EQ (100, rep_weights.representation_get (key4.pub)); @@ -689,7 +566,7 @@ TEST (ledger, representation) nano::keypair key6; nano::open_block block7 (block6.hash (), key6.pub, key5.pub, key5.prv, key5.pub, *pool.generate (key5.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block7).code); - ASSERT_EQ (nano::genesis_amount - 200, rep_weights.representation_get (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); ASSERT_EQ (100, rep_weights.representation_get (key4.pub)); @@ -697,7 +574,7 @@ TEST (ledger, representation) ASSERT_EQ (100, rep_weights.representation_get (key6.pub)); nano::send_block block8 (block6.hash (), key5.pub, 0, key2.prv, key2.pub, *pool.generate (block6.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block8).code); - ASSERT_EQ (nano::genesis_amount - 200, rep_weights.representation_get (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); ASSERT_EQ (0, rep_weights.representation_get (key4.pub)); @@ -705,7 +582,7 @@ TEST (ledger, representation) ASSERT_EQ (100, rep_weights.representation_get (key6.pub)); nano::receive_block block9 (block7.hash (), block8.hash (), key5.prv, key5.pub, *pool.generate (block7.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block9).code); - ASSERT_EQ (nano::genesis_amount - 200, rep_weights.representation_get (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 200, rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, rep_weights.representation_get (key2.pub)); ASSERT_EQ (0, rep_weights.representation_get (key3.pub)); ASSERT_EQ (0, rep_weights.representation_get (key4.pub)); @@ -716,36 +593,34 @@ TEST (ledger, representation) TEST (ledger, double_open) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key2; - nano::send_block send1 (genesis.hash (), key2.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block send1 (nano::dev::genesis->hash (), key2.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); nano::open_block open1 (send1.hash (), key2.pub, key2.pub, key2.prv, key2.pub, *pool.generate (key2.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); - nano::open_block open2 (send1.hash (), nano::dev_genesis_key.pub, key2.pub, key2.prv, key2.pub, *pool.generate (key2.pub)); + nano::open_block open2 (send1.hash (), nano::dev::genesis_key.pub, key2.pub, key2.prv, key2.pub, *pool.generate (key2.pub)); ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, open2).code); } TEST (ledger, double_receive) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key2; - nano::send_block send1 (genesis.hash (), key2.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block send1 (nano::dev::genesis->hash (), key2.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); nano::open_block open1 (send1.hash (), key2.pub, key2.pub, key2.prv, key2.pub, *pool.generate (key2.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); @@ -759,19 +634,18 @@ TEST (votes, check_signature) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.online_weight_minimum = std::numeric_limits::max (); auto & node1 = *system.add_node (node_config); - nano::genesis genesis; nano::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send1); { auto transaction (node1.store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); } - node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ()); + node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); node1.scheduler.flush (); auto election1 = node1.active.election (send1->qualified_root ()); ASSERT_EQ (1, election1->votes ().size ()); - auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 1, send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, send1)); vote1->signature.bytes[0] ^= 1; ASSERT_EQ (nano::vote_code::invalid, node1.vote_processor.vote_blocking (vote1, std::make_shared (node1))); vote1->signature.bytes[0] ^= 1; @@ -783,9 +657,8 @@ TEST (votes, add_one) { nano::system system (1); auto & node1 (*system.nodes[0]); - nano::genesis genesis; nano::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); @@ -793,28 +666,27 @@ TEST (votes, add_one) node1.scheduler.flush (); auto election1 = node1.active.election (send1->qualified_root ()); ASSERT_EQ (1, election1->votes ().size ()); - auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 1, send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, send1)); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); - auto vote2 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 2, send1)); + auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, 0, send1)); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote2)); ASSERT_EQ (2, election1->votes ().size ()); auto votes1 (election1->votes ()); - auto existing1 (votes1.find (nano::dev_genesis_key.pub)); + auto existing1 (votes1.find (nano::dev::genesis_key.pub)); ASSERT_NE (votes1.end (), existing1); ASSERT_EQ (send1->hash (), existing1->second.hash); nano::lock_guard guard (node1.active.mutex); auto winner (*election1->tally ().begin ()); ASSERT_EQ (*send1, *winner.second); - ASSERT_EQ (nano::genesis_amount - 100, winner.first); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, winner.first); } TEST (votes, add_two) { nano::system system{ 1 }; auto & node1 = *system.nodes[0]; - nano::genesis genesis; nano::keypair key1; - auto send1 = std::make_shared (genesis.hash (), key1.pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0); + auto send1 = std::make_shared (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); node1.work_generate_blocking (*send1); auto transaction = node1.store.tx_begin_write (); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); @@ -822,15 +694,15 @@ TEST (votes, add_two) node1.scheduler.flush (); auto election1 = node1.active.election (send1->qualified_root ()); nano::keypair key2; - auto send2 = std::make_shared (genesis.hash (), key2.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0); - auto vote2 = std::make_shared (key2.pub, key2.prv, 1, send2); + auto send2 = std::make_shared (nano::dev::genesis->hash (), key2.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + auto vote2 = std::make_shared (key2.pub, key2.prv, nano::vote::timestamp_min * 1, 0, send2); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote2)); - auto vote1 = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 1, send1); + auto vote1 = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, send1); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); ASSERT_EQ (3, election1->votes ().size ()); auto votes1 = election1->votes (); - ASSERT_NE (votes1.end (), votes1.find (nano::dev_genesis_key.pub)); - ASSERT_EQ (send1->hash (), votes1[nano::dev_genesis_key.pub].hash); + ASSERT_NE (votes1.end (), votes1.find (nano::dev::genesis_key.pub)); + ASSERT_EQ (send1->hash (), votes1[nano::dev::genesis_key.pub].hash); ASSERT_NE (votes1.end (), votes1.find (key2.pub)); ASSERT_EQ (send2->hash (), votes1[key2.pub].hash); ASSERT_EQ (*send1, *election1->winner ()); @@ -843,59 +715,59 @@ TEST (votes, add_existing) { nano::system system; nano::node_config node_config (nano::get_available_port (), system.logging); - node_config.online_weight_minimum = nano::genesis_amount; + node_config.online_weight_minimum = nano::dev::constants.genesis_amount; node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node1 = *system.add_node (node_config); nano::keypair key1; nano::block_builder builder; std::shared_ptr send1 = builder.state () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) // No representative, blocks can't confirm - .balance (nano::genesis_amount / 2 - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) // No representative, blocks can't confirm + .balance (nano::dev::constants.genesis_amount / 2 - nano::MBAN_ratio) .link (key1.pub) .work (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build (); node1.work_generate_blocking (*send1); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code); - node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ()); + node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); node1.scheduler.flush (); auto election1 = node1.active.election (send1->qualified_root ()); - auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 1, send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, send1)); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote1)); // Block is already processed from vote ASSERT_TRUE (node1.active.publish (send1)); - ASSERT_EQ (1, election1->last_votes[nano::dev_genesis_key.pub].timestamp); + ASSERT_EQ (nano::vote::timestamp_min * 1, election1->last_votes[nano::dev::genesis_key.pub].timestamp); nano::keypair key2; std::shared_ptr send2 = builder.state () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) // No representative, blocks can't confirm - .balance (nano::genesis_amount / 2 - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) // No representative, blocks can't confirm + .balance (nano::dev::constants.genesis_amount / 2 - nano::MBAN_ratio) .link (key2.pub) .work (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build (); node1.work_generate_blocking (*send2); - auto vote2 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 2, send2)); + auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, 0, send2)); // Pretend we've waited the timeout nano::unique_lock lock (election1->mutex); - election1->last_votes[nano::dev_genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); + election1->last_votes[nano::dev::genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); lock.unlock (); ASSERT_EQ (nano::vote_code::vote, node1.active.vote (vote2)); ASSERT_FALSE (node1.active.publish (send2)); - ASSERT_EQ (2, election1->last_votes[nano::dev_genesis_key.pub].timestamp); + ASSERT_EQ (nano::vote::timestamp_min * 2, election1->last_votes[nano::dev::genesis_key.pub].timestamp); // Also resend the old vote, and see if we respect the timestamp lock.lock (); - election1->last_votes[nano::dev_genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); + election1->last_votes[nano::dev::genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); lock.unlock (); ASSERT_EQ (nano::vote_code::replay, node1.active.vote (vote1)); - ASSERT_EQ (2, election1->votes ()[nano::dev_genesis_key.pub].timestamp); + ASSERT_EQ (nano::vote::timestamp_min * 2, election1->votes ()[nano::dev::genesis_key.pub].timestamp); auto votes (election1->votes ()); ASSERT_EQ (2, votes.size ()); - ASSERT_NE (votes.end (), votes.find (nano::dev_genesis_key.pub)); - ASSERT_EQ (send2->hash (), votes[nano::dev_genesis_key.pub].hash); + ASSERT_NE (votes.end (), votes.find (nano::dev::genesis_key.pub)); + ASSERT_EQ (send2->hash (), votes[nano::dev::genesis_key.pub].hash); ASSERT_EQ (*send2, *election1->tally ().begin ()->second); } @@ -904,31 +776,30 @@ TEST (votes, add_old) { nano::system system (1); auto & node1 (*system.nodes[0]); - nano::genesis genesis; nano::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); node1.block_confirm (send1); node1.scheduler.flush (); auto election1 = node1.active.election (send1->qualified_root ()); - auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 2, send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, 0, send1)); auto channel (std::make_shared (node1)); node1.vote_processor.vote_blocking (vote1, channel); nano::keypair key2; - auto send2 (std::make_shared (genesis.hash (), key2.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send2 (std::make_shared (nano::dev::genesis->hash (), key2.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send2); - auto vote2 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 1, send2)); + auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, send2)); { nano::lock_guard lock (election1->mutex); - election1->last_votes[nano::dev_genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); + election1->last_votes[nano::dev::genesis_key.pub].time = std::chrono::steady_clock::now () - std::chrono::seconds (20); } node1.vote_processor.vote_blocking (vote2, channel); ASSERT_EQ (2, election1->votes ().size ()); auto votes (election1->votes ()); - ASSERT_NE (votes.end (), votes.find (nano::dev_genesis_key.pub)); - ASSERT_EQ (send1->hash (), votes[nano::dev_genesis_key.pub].hash); + ASSERT_NE (votes.end (), votes.find (nano::dev::genesis_key.pub)); + ASSERT_EQ (send1->hash (), votes[nano::dev::genesis_key.pub].hash); ASSERT_EQ (*send1, *election1->winner ()); } } @@ -938,11 +809,10 @@ TEST (votes, add_old_different_account) { nano::system system (1); auto & node1 (*system.nodes[0]); - nano::genesis genesis; nano::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send1); - auto send2 (std::make_shared (send1->hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send2 (std::make_shared (send1->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send2); ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); ASSERT_EQ (nano::process_result::progress, node1.process (*send2).code); @@ -953,23 +823,23 @@ TEST (votes, add_old_different_account) ASSERT_NE (nullptr, election2); ASSERT_EQ (1, election1->votes ().size ()); ASSERT_EQ (1, election2->votes ().size ()); - auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 2, send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, 0, send1)); auto channel (std::make_shared (node1)); auto vote_result1 (node1.vote_processor.vote_blocking (vote1, channel)); ASSERT_EQ (nano::vote_code::vote, vote_result1); ASSERT_EQ (2, election1->votes ().size ()); ASSERT_EQ (1, election2->votes ().size ()); - auto vote2 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 1, send2)); + auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, send2)); auto vote_result2 (node1.vote_processor.vote_blocking (vote2, channel)); ASSERT_EQ (nano::vote_code::vote, vote_result2); ASSERT_EQ (2, election1->votes ().size ()); ASSERT_EQ (2, election2->votes ().size ()); auto votes1 (election1->votes ()); auto votes2 (election2->votes ()); - ASSERT_NE (votes1.end (), votes1.find (nano::dev_genesis_key.pub)); - ASSERT_NE (votes2.end (), votes2.find (nano::dev_genesis_key.pub)); - ASSERT_EQ (send1->hash (), votes1[nano::dev_genesis_key.pub].hash); - ASSERT_EQ (send2->hash (), votes2[nano::dev_genesis_key.pub].hash); + ASSERT_NE (votes1.end (), votes1.find (nano::dev::genesis_key.pub)); + ASSERT_NE (votes2.end (), votes2.find (nano::dev::genesis_key.pub)); + ASSERT_EQ (send1->hash (), votes1[nano::dev::genesis_key.pub].hash); + ASSERT_EQ (send2->hash (), votes2[nano::dev::genesis_key.pub].hash); ASSERT_EQ (*send1, *election1->winner ()); ASSERT_EQ (*send2, *election2->winner ()); } @@ -979,27 +849,26 @@ TEST (votes, add_cooldown) { nano::system system (1); auto & node1 (*system.nodes[0]); - nano::genesis genesis; nano::keypair key1; - auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send1); auto transaction (node1.store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *send1).code); node1.block_confirm (send1); node1.scheduler.flush (); auto election1 = node1.active.election (send1->qualified_root ()); - auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 1, send1)); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 1, 0, send1)); auto channel (std::make_shared (node1)); node1.vote_processor.vote_blocking (vote1, channel); nano::keypair key2; - auto send2 (std::make_shared (genesis.hash (), key2.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send2 (std::make_shared (nano::dev::genesis->hash (), key2.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send2); - auto vote2 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 2, send2)); + auto vote2 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * 2, 0, send2)); node1.vote_processor.vote_blocking (vote2, channel); ASSERT_EQ (2, election1->votes ().size ()); auto votes (election1->votes ()); - ASSERT_NE (votes.end (), votes.find (nano::dev_genesis_key.pub)); - ASSERT_EQ (send1->hash (), votes[nano::dev_genesis_key.pub].hash); + ASSERT_NE (votes.end (), votes.find (nano::dev::genesis_key.pub)); + ASSERT_EQ (send1->hash (), votes[nano::dev::genesis_key.pub].hash); ASSERT_EQ (*send1, *election1->winner ()); } @@ -1009,29 +878,27 @@ TEST (ledger, successor) nano::system system (1); auto & node1 (*system.nodes[0]); nano::keypair key1; - nano::genesis genesis; - nano::send_block send1 (genesis.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0); + nano::send_block send1 (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); node1.work_generate_blocking (send1); auto transaction (node1.store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, send1).code); - ASSERT_EQ (send1, *node1.ledger.successor (transaction, nano::qualified_root (nano::root (0), genesis.hash ()))); - ASSERT_EQ (*genesis.open, *node1.ledger.successor (transaction, genesis.open->qualified_root ())); + ASSERT_EQ (send1, *node1.ledger.successor (transaction, nano::qualified_root (nano::root (0), nano::dev::genesis->hash ()))); + ASSERT_EQ (*nano::dev::genesis, *node1.ledger.successor (transaction, nano::dev::genesis->qualified_root ())); ASSERT_EQ (nullptr, node1.ledger.successor (transaction, nano::qualified_root (0))); } TEST (ledger, fail_change_old) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::change_block block (genesis.hash (), key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::change_block block (nano::dev::genesis->hash (), key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); auto result1 (ledger.process (transaction, block)); ASSERT_EQ (nano::process_result::progress, result1.code); auto result2 (ledger.process (transaction, block)); @@ -1041,16 +908,15 @@ TEST (ledger, fail_change_old) TEST (ledger, fail_change_gap_previous) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::change_block block (1, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::root (1))); + nano::change_block block (1, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::root (1))); auto result1 (ledger.process (transaction, block)); ASSERT_EQ (nano::process_result::gap_previous, result1.code); } @@ -1058,16 +924,15 @@ TEST (ledger, fail_change_gap_previous) TEST (ledger, fail_change_bad_signature) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::change_block block (genesis.hash (), key1.pub, nano::keypair ().prv, 0, *pool.generate (genesis.hash ())); + nano::change_block block (nano::dev::genesis->hash (), key1.pub, nano::keypair ().prv, 0, *pool.generate (nano::dev::genesis->hash ())); auto result1 (ledger.process (transaction, block)); ASSERT_EQ (nano::process_result::bad_signature, result1.code); } @@ -1075,20 +940,19 @@ TEST (ledger, fail_change_bad_signature) TEST (ledger, fail_change_fork) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::change_block block1 (genesis.hash (), key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::change_block block1 (nano::dev::genesis->hash (), key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); auto result1 (ledger.process (transaction, block1)); ASSERT_EQ (nano::process_result::progress, result1.code); nano::keypair key2; - nano::change_block block2 (genesis.hash (), key2.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::change_block block2 (nano::dev::genesis->hash (), key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); auto result2 (ledger.process (transaction, block2)); ASSERT_EQ (nano::process_result::fork, result2.code); } @@ -1096,16 +960,15 @@ TEST (ledger, fail_change_fork) TEST (ledger, fail_send_old) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block (genesis.hash (), key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block (nano::dev::genesis->hash (), key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); auto result1 (ledger.process (transaction, block)); ASSERT_EQ (nano::process_result::progress, result1.code); auto result2 (ledger.process (transaction, block)); @@ -1115,16 +978,15 @@ TEST (ledger, fail_send_old) TEST (ledger, fail_send_gap_previous) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block (1, key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (nano::root (1))); + nano::send_block block (1, key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::root (1))); auto result1 (ledger.process (transaction, block)); ASSERT_EQ (nano::process_result::gap_previous, result1.code); } @@ -1132,16 +994,15 @@ TEST (ledger, fail_send_gap_previous) TEST (ledger, fail_send_bad_signature) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block (genesis.hash (), key1.pub, 1, nano::keypair ().prv, 0, *pool.generate (genesis.hash ())); + nano::send_block block (nano::dev::genesis->hash (), key1.pub, 1, nano::keypair ().prv, 0, *pool.generate (nano::dev::genesis->hash ())); auto result1 (ledger.process (transaction, block)); ASSERT_EQ (nano::process_result::bad_signature, result1.code); } @@ -1149,54 +1010,51 @@ TEST (ledger, fail_send_bad_signature) TEST (ledger, fail_send_negative_spend) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); nano::keypair key2; - nano::send_block block2 (block1.hash (), key2.pub, 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ())); + nano::send_block block2 (block1.hash (), key2.pub, 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block1.hash ())); ASSERT_EQ (nano::process_result::negative_spend, ledger.process (transaction, block2).code); } TEST (ledger, fail_send_fork) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); nano::keypair key2; - nano::send_block block2 (genesis.hash (), key2.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block2 (nano::dev::genesis->hash (), key2.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, block2).code); } TEST (ledger, fail_open_old) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); nano::open_block block2 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); @@ -1206,14 +1064,13 @@ TEST (ledger, fail_open_old) TEST (ledger, fail_open_gap_source) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; nano::open_block block2 (1, 1, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); auto result2 (ledger.process (transaction, block2)); @@ -1223,16 +1080,15 @@ TEST (ledger, fail_open_gap_source) TEST (ledger, fail_open_bad_signature) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); nano::open_block block2 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); block2.signature.clear (); @@ -1242,61 +1098,58 @@ TEST (ledger, fail_open_bad_signature) TEST (ledger, fail_open_fork_previous) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); - nano::send_block block2 (block1.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ())); + nano::send_block block2 (block1.hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); nano::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code); nano::open_block block4 (block2.hash (), 1, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, block4).code); - ASSERT_EQ (store->account_count (transaction), ledger.cache.account_count); + ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } TEST (ledger, fail_open_account_mismatch) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); nano::keypair badkey; nano::open_block block2 (block1.hash (), 1, badkey.pub, badkey.prv, badkey.pub, *pool.generate (badkey.pub)); ASSERT_NE (nano::process_result::progress, ledger.process (transaction, block2).code); - ASSERT_EQ (store->account_count (transaction), ledger.cache.account_count); + ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } TEST (ledger, fail_receive_old) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); - nano::send_block block2 (block1.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ())); + nano::send_block block2 (block1.hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); nano::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code); @@ -1308,19 +1161,18 @@ TEST (ledger, fail_receive_old) TEST (ledger, fail_receive_gap_source) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); auto result1 (ledger.process (transaction, block1)); ASSERT_EQ (nano::process_result::progress, result1.code); - nano::send_block block2 (block1.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ())); + nano::send_block block2 (block1.hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block1.hash ())); auto result2 (ledger.process (transaction, block2)); ASSERT_EQ (nano::process_result::progress, result2.code); nano::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); @@ -1334,16 +1186,15 @@ TEST (ledger, fail_receive_gap_source) TEST (ledger, fail_receive_overreceive) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); auto result1 (ledger.process (transaction, block1)); ASSERT_EQ (nano::process_result::progress, result1.code); nano::open_block block2 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); @@ -1357,19 +1208,18 @@ TEST (ledger, fail_receive_overreceive) TEST (ledger, fail_receive_bad_signature) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); auto result1 (ledger.process (transaction, block1)); ASSERT_EQ (nano::process_result::progress, result1.code); - nano::send_block block2 (block1.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ())); + nano::send_block block2 (block1.hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block1.hash ())); auto result2 (ledger.process (transaction, block2)); ASSERT_EQ (nano::process_result::progress, result2.code); nano::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); @@ -1383,19 +1233,18 @@ TEST (ledger, fail_receive_bad_signature) TEST (ledger, fail_receive_gap_previous_opened) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); auto result1 (ledger.process (transaction, block1)); ASSERT_EQ (nano::process_result::progress, result1.code); - nano::send_block block2 (block1.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ())); + nano::send_block block2 (block1.hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block1.hash ())); auto result2 (ledger.process (transaction, block2)); ASSERT_EQ (nano::process_result::progress, result2.code); nano::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); @@ -1409,19 +1258,18 @@ TEST (ledger, fail_receive_gap_previous_opened) TEST (ledger, fail_receive_gap_previous_unopened) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); auto result1 (ledger.process (transaction, block1)); ASSERT_EQ (nano::process_result::progress, result1.code); - nano::send_block block2 (block1.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ())); + nano::send_block block2 (block1.hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block1.hash ())); auto result2 (ledger.process (transaction, block2)); ASSERT_EQ (nano::process_result::progress, result2.code); nano::receive_block block3 (1, block2.hash (), key1.prv, key1.pub, *pool.generate (nano::root (1))); @@ -1432,19 +1280,18 @@ TEST (ledger, fail_receive_gap_previous_unopened) TEST (ledger, fail_receive_fork_previous) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block1 (genesis.hash (), key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); auto result1 (ledger.process (transaction, block1)); ASSERT_EQ (nano::process_result::progress, result1.code); - nano::send_block block2 (block1.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ())); + nano::send_block block2 (block1.hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block1.hash ())); auto result2 (ledger.process (transaction, block2)); ASSERT_EQ (nano::process_result::progress, result2.code); nano::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); @@ -1462,22 +1309,21 @@ TEST (ledger, fail_receive_fork_previous) TEST (ledger, fail_receive_received_source) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; - nano::send_block block1 (genesis.hash (), key1.pub, 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), key1.pub, 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); auto result1 (ledger.process (transaction, block1)); ASSERT_EQ (nano::process_result::progress, result1.code); - nano::send_block block2 (block1.hash (), key1.pub, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ())); + nano::send_block block2 (block1.hash (), key1.pub, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block1.hash ())); auto result2 (ledger.process (transaction, block2)); ASSERT_EQ (nano::process_result::progress, result2.code); - nano::send_block block6 (block2.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block2.hash ())); + nano::send_block block6 (block2.hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block2.hash ())); auto result6 (ledger.process (transaction, block6)); ASSERT_EQ (nano::process_result::progress, result6.code); nano::open_block block3 (block1.hash (), 1, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); @@ -1498,10 +1344,10 @@ TEST (ledger, fail_receive_received_source) TEST (ledger, latest_empty) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); nano::keypair key; auto transaction (store->tx_begin_read ()); auto latest (ledger.latest (transaction, key.pub)); @@ -1511,66 +1357,62 @@ TEST (ledger, latest_empty) TEST (ledger, latest_root) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key; ASSERT_EQ (key.pub, ledger.latest_root (transaction, key.pub)); - auto hash1 (ledger.latest (transaction, nano::dev_genesis_key.pub)); - nano::send_block send (hash1, 0, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (hash1)); + auto hash1 (ledger.latest (transaction, nano::dev::genesis_key.pub)); + nano::send_block send (hash1, 0, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (hash1)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); - ASSERT_EQ (send.hash (), ledger.latest_root (transaction, nano::dev_genesis_key.pub)); + ASSERT_EQ (send.hash (), ledger.latest_root (transaction, nano::dev::genesis_key.pub)); } TEST (ledger, change_representative_move_representation) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); nano::keypair key1; auto transaction (store->tx_begin_write ()); - nano::genesis genesis; - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - auto hash1 (genesis.hash ()); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::dev_genesis_key.pub)); - nano::send_block send (hash1, key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (hash1)); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis_key.pub)); + nano::send_block send (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); - ASSERT_EQ (0, ledger.weight (nano::dev_genesis_key.pub)); + ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); nano::keypair key2; - nano::change_block change (send.hash (), key2.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send.hash ())); + nano::change_block change (send.hash (), key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change).code); nano::keypair key3; nano::open_block open (send.hash (), key3.pub, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); - ASSERT_EQ (nano::genesis_amount, ledger.weight (key3.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (key3.pub)); } TEST (ledger, send_open_receive_rollback) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - nano::genesis genesis; - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::account_info info1; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info1)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1)); nano::keypair key1; - nano::send_block send1 (info1.head, key1.pub, nano::genesis_amount - 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head)); + nano::send_block send1 (info1.head, key1.pub, nano::dev::constants.genesis_amount - 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head)); auto return1 (ledger.process (transaction, send1)); ASSERT_EQ (nano::process_result::progress, return1.code); - nano::send_block send2 (send1.hash (), key1.pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::send_block send2 (send1.hash (), key1.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); auto return2 (ledger.process (transaction, send2)); ASSERT_EQ (nano::process_result::progress, return2.code); nano::keypair key2; @@ -1582,52 +1424,51 @@ TEST (ledger, send_open_receive_rollback) ASSERT_EQ (nano::process_result::progress, return5.code); nano::keypair key3; ASSERT_EQ (100, ledger.weight (key2.pub)); - ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_EQ (0, ledger.weight (key3.pub)); - nano::change_block change1 (send2.hash (), key3.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); + nano::change_block change1 (send2.hash (), key3.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send2.hash ())); auto return6 (ledger.process (transaction, change1)); ASSERT_EQ (nano::process_result::progress, return6.code); ASSERT_EQ (100, ledger.weight (key2.pub)); - ASSERT_EQ (0, ledger.weight (nano::dev_genesis_key.pub)); - ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (key3.pub)); + ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, ledger.weight (key3.pub)); ASSERT_FALSE (ledger.rollback (transaction, receive.hash ())); ASSERT_EQ (50, ledger.weight (key2.pub)); - ASSERT_EQ (0, ledger.weight (nano::dev_genesis_key.pub)); - ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (key3.pub)); + ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, ledger.weight (key3.pub)); ASSERT_FALSE (ledger.rollback (transaction, open.hash ())); ASSERT_EQ (0, ledger.weight (key2.pub)); - ASSERT_EQ (0, ledger.weight (nano::dev_genesis_key.pub)); - ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (key3.pub)); + ASSERT_EQ (0, ledger.weight (nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, ledger.weight (key3.pub)); ASSERT_FALSE (ledger.rollback (transaction, change1.hash ())); ASSERT_EQ (0, ledger.weight (key2.pub)); ASSERT_EQ (0, ledger.weight (key3.pub)); - ASSERT_EQ (nano::genesis_amount - 100, ledger.weight (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_FALSE (ledger.rollback (transaction, send2.hash ())); ASSERT_EQ (0, ledger.weight (key2.pub)); ASSERT_EQ (0, ledger.weight (key3.pub)); - ASSERT_EQ (nano::genesis_amount - 50, ledger.weight (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 50, ledger.weight (nano::dev::genesis_key.pub)); ASSERT_FALSE (ledger.rollback (transaction, send1.hash ())); ASSERT_EQ (0, ledger.weight (key2.pub)); ASSERT_EQ (0, ledger.weight (key3.pub)); - ASSERT_EQ (nano::genesis_amount - 0, ledger.weight (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - 0, ledger.weight (nano::dev::genesis_key.pub)); } TEST (ledger, bootstrap_rep_weight) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); nano::account_info info1; nano::keypair key2; - nano::genesis genesis; - nano::work_pool pool (std::numeric_limits::max ()); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; { auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info1)); - nano::send_block send (info1.head, key2.pub, std::numeric_limits::max () - 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head)); + store->initialize (transaction, ledger.cache); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1)); + nano::send_block send (info1.head, key2.pub, std::numeric_limits::max () - 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); } ASSERT_EQ (2, ledger.cache.block_count); @@ -1638,8 +1479,8 @@ TEST (ledger, bootstrap_rep_weight) } { auto transaction (store->tx_begin_write ()); - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info1)); - nano::send_block send (info1.head, key2.pub, std::numeric_limits::max () - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1)); + nano::send_block send (info1.head, key2.pub, std::numeric_limits::max () - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); } ASSERT_EQ (3, ledger.cache.block_count); @@ -1652,28 +1493,27 @@ TEST (ledger, bootstrap_rep_weight) TEST (ledger, block_destination_source) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair dest; - nano::uint128_t balance (nano::genesis_amount); + nano::uint128_t balance (nano::dev::constants.genesis_amount); balance -= nano::MBAN_ratio; - nano::send_block block1 (genesis.hash (), dest.pub, balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block block1 (nano::dev::genesis->hash (), dest.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); balance -= nano::MBAN_ratio; - nano::send_block block2 (block1.hash (), nano::genesis_account, balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block1.hash ())); + nano::send_block block2 (block1.hash (), nano::dev::genesis->account (), balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block1.hash ())); balance += nano::MBAN_ratio; - nano::receive_block block3 (block2.hash (), block2.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block2.hash ())); + nano::receive_block block3 (block2.hash (), block2.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block2.hash ())); balance -= nano::MBAN_ratio; - nano::state_block block4 (nano::genesis_account, block3.hash (), nano::genesis_account, balance, dest.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block3.hash ())); + nano::state_block block4 (nano::dev::genesis->account (), block3.hash (), nano::dev::genesis->account (), balance, dest.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block3.hash ())); balance -= nano::MBAN_ratio; - nano::state_block block5 (nano::genesis_account, block4.hash (), nano::genesis_account, balance, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block4.hash ())); + nano::state_block block5 (nano::dev::genesis->account (), block4.hash (), nano::dev::genesis->account (), balance, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block4.hash ())); balance += nano::MBAN_ratio; - nano::state_block block6 (nano::genesis_account, block5.hash (), nano::genesis_account, balance, block5.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (block5.hash ())); + nano::state_block block6 (nano::dev::genesis->account (), block5.hash (), nano::dev::genesis->account (), balance, block5.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (block5.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block1).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block2).code); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, block3).code); @@ -1683,70 +1523,68 @@ TEST (ledger, block_destination_source) ASSERT_EQ (balance, ledger.balance (transaction, block6.hash ())); ASSERT_EQ (dest.pub, ledger.block_destination (transaction, block1)); ASSERT_TRUE (ledger.block_source (transaction, block1).is_zero ()); - ASSERT_EQ (nano::genesis_account, ledger.block_destination (transaction, block2)); + ASSERT_EQ (nano::dev::genesis->account (), ledger.block_destination (transaction, block2)); ASSERT_TRUE (ledger.block_source (transaction, block2).is_zero ()); - ASSERT_TRUE (ledger.block_destination (transaction, block3).is_zero ()); + ASSERT_TRUE (ledger.block_destination (transaction, block3) == nullptr); ASSERT_EQ (block2.hash (), ledger.block_source (transaction, block3)); ASSERT_EQ (dest.pub, ledger.block_destination (transaction, block4)); ASSERT_TRUE (ledger.block_source (transaction, block4).is_zero ()); - ASSERT_EQ (nano::genesis_account, ledger.block_destination (transaction, block5)); + ASSERT_EQ (nano::dev::genesis->account (), ledger.block_destination (transaction, block5)); ASSERT_TRUE (ledger.block_source (transaction, block5).is_zero ()); - ASSERT_TRUE (ledger.block_destination (transaction, block6).is_zero ()); + ASSERT_TRUE (ledger.block_destination (transaction, block6) == nullptr); ASSERT_EQ (block5.hash (), ledger.block_source (transaction, block6)); } TEST (ledger, state_account) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_EQ (nano::genesis_account, ledger.account (transaction, send1.hash ())); + ASSERT_EQ (nano::dev::genesis->account (), ledger.account (transaction, send1.hash ())); } TEST (ledger, state_send_receive) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->block_exists (transaction, send1.hash ())); - auto send2 (store->block_get (transaction, send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); + auto send2 (store->block.get (transaction, send1.hash ())); ASSERT_NE (nullptr, send2); ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.weight (nano::genesis_account)); - ASSERT_TRUE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.weight (nano::dev::genesis->account ())); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_EQ (2, send2->sideband ().height); ASSERT_TRUE (send2->sideband ().details.is_send); ASSERT_FALSE (send2->sideband ().details.is_receive); ASSERT_FALSE (send2->sideband ().details.is_epoch); - nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block receive1 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_TRUE (store->block_exists (transaction, receive1.hash ())); - auto receive2 (store->block_get (transaction, receive1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, receive1.hash ())); + auto receive2 (store->block.get (transaction, receive1.hash ())); ASSERT_NE (nullptr, receive2); ASSERT_EQ (receive1, *receive2); - ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, receive1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); - ASSERT_FALSE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); - ASSERT_EQ (store->account_count (transaction), ledger.cache.account_count); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); + ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); ASSERT_EQ (3, receive2->sideband ().height); ASSERT_FALSE (receive2->sideband ().details.is_send); ASSERT_TRUE (receive2->sideband ().details.is_receive); @@ -1756,32 +1594,31 @@ TEST (ledger, state_send_receive) TEST (ledger, state_receive) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::send_block send1 (nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->block_exists (transaction, send1.hash ())); - auto send2 (store->block_get (transaction, send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); + auto send2 (store->block.get (transaction, send1.hash ())); ASSERT_NE (nullptr, send2); ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.weight (nano::genesis_account)); - nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.weight (nano::dev::genesis->account ())); + nano::state_block receive1 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_TRUE (store->block_exists (transaction, receive1.hash ())); - auto receive2 (store->block_get (transaction, receive1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, receive1.hash ())); + auto receive2 (store->block.get (transaction, receive1.hash ())); ASSERT_NE (nullptr, receive2); ASSERT_EQ (receive1, *receive2); - ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, receive1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (3, receive2->sideband ().height); ASSERT_FALSE (receive2->sideband ().details.is_send); ASSERT_TRUE (receive2->sideband ().details.is_receive); @@ -1791,25 +1628,24 @@ TEST (ledger, state_receive) TEST (ledger, state_rep_change) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair rep; - nano::state_block change1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block change1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), rep.pub, nano::dev::constants.genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change1).code); - ASSERT_TRUE (store->block_exists (transaction, change1.hash ())); - auto change2 (store->block_get (transaction, change1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, change1.hash ())); + auto change2 (store->block.get (transaction, change1.hash ())); ASSERT_NE (nullptr, change2); ASSERT_EQ (change1, *change2); - ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, change1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, change1.hash ())); ASSERT_EQ (0, ledger.amount (transaction, change1.hash ())); - ASSERT_EQ (0, ledger.weight (nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (rep.pub)); + ASSERT_EQ (0, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (rep.pub)); ASSERT_EQ (2, change2->sideband ().height); ASSERT_FALSE (change2->sideband ().details.is_send); ASSERT_FALSE (change2->sideband ().details.is_receive); @@ -1819,36 +1655,35 @@ TEST (ledger, state_rep_change) TEST (ledger, state_open) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->block_exists (transaction, send1.hash ())); - auto send2 (store->block_get (transaction, send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); + auto send2 (store->block.get (transaction, send1.hash ())); ASSERT_NE (nullptr, send2); ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.weight (nano::genesis_account)); - ASSERT_TRUE (store->pending_exists (transaction, nano::pending_key (destination.pub, send1.hash ()))); - nano::state_block open1 (destination.pub, 0, nano::genesis_account, nano::MBAN_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.weight (nano::dev::genesis->account ())); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (destination.pub, send1.hash ()))); + nano::state_block open1 (destination.pub, 0, nano::dev::genesis->account (), nano::MBAN_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); - ASSERT_FALSE (store->pending_exists (transaction, nano::pending_key (destination.pub, send1.hash ()))); - ASSERT_TRUE (store->block_exists (transaction, open1.hash ())); - auto open2 (store->block_get (transaction, open1.hash ())); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (destination.pub, send1.hash ()))); + ASSERT_TRUE (store->block.exists (transaction, open1.hash ())); + auto open2 (store->block.get (transaction, open1.hash ())); ASSERT_NE (nullptr, open2); ASSERT_EQ (open1, *open2); ASSERT_EQ (nano::MBAN_ratio, ledger.balance (transaction, open1.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, open1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); - ASSERT_EQ (ledger.cache.account_count, store->account_count (transaction)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (ledger.cache.account_count, store->account.count (transaction)); ASSERT_EQ (1, open2->sideband ().height); ASSERT_FALSE (open2->sideband ().details.is_send); ASSERT_TRUE (open2->sideband ().details.is_receive); @@ -1859,17 +1694,16 @@ TEST (ledger, state_open) TEST (ledger, send_after_state_fail) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::send_block send2 (send1.hash (), nano::genesis_account, nano::genesis_amount - (2 * nano::MBAN_ratio), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::send_block send2 (send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - (2 * nano::MBAN_ratio), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, send2).code); } @@ -1877,17 +1711,16 @@ TEST (ledger, send_after_state_fail) TEST (ledger, receive_after_state_fail) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::receive_block receive1 (send1.hash (), send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::receive_block receive1 (send1.hash (), send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, receive1).code); } @@ -1895,129 +1728,123 @@ TEST (ledger, receive_after_state_fail) TEST (ledger, change_after_state_fail) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); nano::keypair rep; - nano::change_block change1 (send1.hash (), rep.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::change_block change1 (send1.hash (), rep.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, change1).code); } TEST (ledger, state_unreceivable_fail) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::send_block send1 (nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->block_exists (transaction, send1.hash ())); - auto send2 (store->block_get (transaction, send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); + auto send2 (store->block.get (transaction, send1.hash ())); ASSERT_NE (nullptr, send2); ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.weight (nano::genesis_account)); - nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.weight (nano::dev::genesis->account ())); + nano::state_block receive1 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::gap_source, ledger.process (transaction, receive1).code); } TEST (ledger, state_receive_bad_amount_fail) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::send_block send1 (nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->block_exists (transaction, send1.hash ())); - auto send2 (store->block_get (transaction, send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); + auto send2 (store->block.get (transaction, send1.hash ())); ASSERT_NE (nullptr, send2); ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.weight (nano::genesis_account)); - nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.weight (nano::dev::genesis->account ())); + nano::state_block receive1 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::balance_mismatch, ledger.process (transaction, receive1).code); } TEST (ledger, state_no_link_amount_fail) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); nano::keypair rep; - nano::state_block change1 (nano::genesis_account, send1.hash (), rep.pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block change1 (nano::dev::genesis->account (), send1.hash (), rep.pub, nano::dev::constants.genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::balance_mismatch, ledger.process (transaction, change1).code); } TEST (ledger, state_receive_wrong_account_fail) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->block_exists (transaction, send1.hash ())); - auto send2 (store->block_get (transaction, send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); + auto send2 (store->block.get (transaction, send1.hash ())); ASSERT_NE (nullptr, send2); ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.weight (nano::dev::genesis->account ())); nano::keypair key; - nano::state_block receive1 (key.pub, 0, nano::genesis_account, nano::MBAN_ratio, send1.hash (), key.prv, key.pub, *pool.generate (key.pub)); + nano::state_block receive1 (key.pub, 0, nano::dev::genesis->account (), nano::MBAN_ratio, send1.hash (), key.prv, key.pub, *pool.generate (key.pub)); ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, receive1).code); } TEST (ledger, state_open_state_fork) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block open1 (destination.pub, 0, nano::genesis_account, nano::MBAN_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::state_block open1 (destination.pub, 0, nano::dev::genesis->account (), nano::MBAN_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); - nano::open_block open2 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::open_block open2 (send1.hash (), nano::dev::genesis->account (), destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, open2).code); ASSERT_EQ (open1.root (), open2.root ()); } @@ -2025,83 +1852,79 @@ TEST (ledger, state_open_state_fork) TEST (ledger, state_state_open_fork) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::open_block open1 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); - nano::state_block open2 (destination.pub, 0, nano::genesis_account, nano::MBAN_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::state_block open2 (destination.pub, 0, nano::dev::genesis->account (), nano::MBAN_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, open2).code); ASSERT_EQ (open1.root (), open2.root ()); - ASSERT_EQ (store->account_count (transaction), ledger.cache.account_count); + ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } TEST (ledger, state_open_previous_fail) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block open1 (destination.pub, 1, nano::genesis_account, nano::MBAN_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (1)); + nano::state_block open1 (destination.pub, 1, nano::dev::genesis->account (), nano::MBAN_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (1)); ASSERT_EQ (nano::process_result::gap_previous, ledger.process (transaction, open1).code); } TEST (ledger, state_open_source_fail) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block open1 (destination.pub, 0, nano::genesis_account, 0, 0, destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::state_block open1 (destination.pub, 0, nano::dev::genesis->account (), 0, 0, destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::gap_source, ledger.process (transaction, open1).code); } TEST (ledger, state_send_change) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair rep; - nano::state_block send1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), rep.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->block_exists (transaction, send1.hash ())); - auto send2 (store->block_get (transaction, send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); + auto send2 (store->block.get (transaction, send1.hash ())); ASSERT_NE (nullptr, send2); ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (0, ledger.weight (nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.weight (rep.pub)); + ASSERT_EQ (0, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.weight (rep.pub)); ASSERT_EQ (2, send2->sideband ().height); ASSERT_TRUE (send2->sideband ().details.is_send); ASSERT_FALSE (send2->sideband ().details.is_receive); @@ -2111,34 +1934,33 @@ TEST (ledger, state_send_change) TEST (ledger, state_receive_change) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->block_exists (transaction, send1.hash ())); - auto send2 (store->block_get (transaction, send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); + auto send2 (store->block.get (transaction, send1.hash ())); ASSERT_NE (nullptr, send2); ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.balance (transaction, send1.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.weight (nano::dev::genesis->account ())); nano::keypair rep; - nano::state_block receive1 (nano::genesis_account, send1.hash (), rep.pub, nano::genesis_amount, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block receive1 (nano::dev::genesis->account (), send1.hash (), rep.pub, nano::dev::constants.genesis_amount, send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_TRUE (store->block_exists (transaction, receive1.hash ())); - auto receive2 (store->block_get (transaction, receive1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, receive1.hash ())); + auto receive2 (store->block.get (transaction, receive1.hash ())); ASSERT_NE (nullptr, receive2); ASSERT_EQ (receive1, *receive2); - ASSERT_EQ (nano::genesis_amount, ledger.balance (transaction, receive1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.balance (transaction, receive1.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (0, ledger.weight (nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (rep.pub)); + ASSERT_EQ (0, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (rep.pub)); ASSERT_EQ (3, receive2->sideband ().height); ASSERT_FALSE (receive2->sideband ().details.is_send); ASSERT_TRUE (receive2->sideband ().details.is_receive); @@ -2148,279 +1970,269 @@ TEST (ledger, state_receive_change) TEST (ledger, state_open_old) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::open_block open1 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); ASSERT_EQ (nano::MBAN_ratio, ledger.balance (transaction, open1.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, open1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); } TEST (ledger, state_receive_old) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block send2 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - (2 * nano::MBAN_ratio), destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block send2 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - (2 * nano::MBAN_ratio), destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); - nano::open_block open1 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); nano::receive_block receive1 (open1.hash (), send2.hash (), destination.prv, destination.pub, *pool.generate (open1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); ASSERT_EQ (2 * nano::MBAN_ratio, ledger.balance (transaction, receive1.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, receive1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); } TEST (ledger, state_rollback_send) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->block_exists (transaction, send1.hash ())); - auto send2 (store->block_get (transaction, send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); + auto send2 (store->block.get (transaction, send1.hash ())); ASSERT_NE (nullptr, send2); ASSERT_EQ (send1, *send2); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.weight (nano::dev::genesis->account ())); nano::pending_info info; - ASSERT_FALSE (store->pending_get (transaction, nano::pending_key (nano::genesis_account, send1.hash ()), info)); - ASSERT_EQ (nano::genesis_account, info.source); + ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info)); + ASSERT_EQ (nano::dev::genesis->account (), info.source); ASSERT_EQ (nano::MBAN_ratio, info.amount.number ()); ASSERT_FALSE (ledger.rollback (transaction, send1.hash ())); - ASSERT_FALSE (store->block_exists (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); - ASSERT_FALSE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); - ASSERT_TRUE (store->block_successor (transaction, genesis.hash ()).is_zero ()); - ASSERT_EQ (store->account_count (transaction), ledger.cache.account_count); + ASSERT_FALSE (store->block.exists (transaction, send1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); + ASSERT_TRUE (store->block.successor (transaction, nano::dev::genesis->hash ()).is_zero ()); + ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } TEST (ledger, state_rollback_receive) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block receive1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block receive1 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_FALSE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, receive1.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), receive1.hash ()))); ASSERT_FALSE (ledger.rollback (transaction, receive1.hash ())); nano::pending_info info; - ASSERT_FALSE (store->pending_get (transaction, nano::pending_key (nano::genesis_account, send1.hash ()), info)); - ASSERT_EQ (nano::genesis_account, info.source); + ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info)); + ASSERT_EQ (nano::dev::genesis->account (), info.source); ASSERT_EQ (nano::MBAN_ratio, info.amount.number ()); - ASSERT_FALSE (store->block_exists (transaction, receive1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.weight (nano::genesis_account)); - ASSERT_EQ (store->account_count (transaction), ledger.cache.account_count); + ASSERT_FALSE (store->block.exists (transaction, receive1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.weight (nano::dev::genesis->account ())); + ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } TEST (ledger, state_rollback_received_send) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); nano::state_block receive1 (key.pub, 0, key.pub, nano::MBAN_ratio, send1.hash (), key.prv, key.pub, *pool.generate (key.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_FALSE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, receive1.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), receive1.hash ()))); ASSERT_FALSE (ledger.rollback (transaction, send1.hash ())); - ASSERT_FALSE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); - ASSERT_FALSE (store->block_exists (transaction, send1.hash ())); - ASSERT_FALSE (store->block_exists (transaction, receive1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); + ASSERT_FALSE (store->block.exists (transaction, send1.hash ())); + ASSERT_FALSE (store->block.exists (transaction, receive1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (0, ledger.account_balance (transaction, key.pub)); ASSERT_EQ (0, ledger.weight (key.pub)); - ASSERT_EQ (store->account_count (transaction), ledger.cache.account_count); + ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } TEST (ledger, state_rep_change_rollback) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair rep; - nano::state_block change1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block change1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), rep.pub, nano::dev::constants.genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change1).code); ASSERT_FALSE (ledger.rollback (transaction, change1.hash ())); - ASSERT_FALSE (store->block_exists (transaction, change1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_FALSE (store->block.exists (transaction, change1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (0, ledger.weight (rep.pub)); } TEST (ledger, state_open_rollback) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block open1 (destination.pub, 0, nano::genesis_account, nano::MBAN_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::state_block open1 (destination.pub, 0, nano::dev::genesis->account (), nano::MBAN_ratio, send1.hash (), destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); ASSERT_FALSE (ledger.rollback (transaction, open1.hash ())); - ASSERT_FALSE (store->block_exists (transaction, open1.hash ())); + ASSERT_FALSE (store->block.exists (transaction, open1.hash ())); ASSERT_EQ (0, ledger.account_balance (transaction, destination.pub)); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.weight (nano::dev::genesis->account ())); nano::pending_info info; - ASSERT_FALSE (store->pending_get (transaction, nano::pending_key (destination.pub, send1.hash ()), info)); - ASSERT_EQ (nano::genesis_account, info.source); + ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (destination.pub, send1.hash ()), info)); + ASSERT_EQ (nano::dev::genesis->account (), info.source); ASSERT_EQ (nano::MBAN_ratio, info.amount.number ()); - ASSERT_EQ (store->account_count (transaction), ledger.cache.account_count); + ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } TEST (ledger, state_send_change_rollback) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair rep; - nano::state_block send1 (nano::genesis_account, genesis.hash (), rep.pub, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), rep.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_FALSE (ledger.rollback (transaction, send1.hash ())); - ASSERT_FALSE (store->block_exists (transaction, send1.hash ())); - ASSERT_EQ (nano::genesis_amount, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount, ledger.weight (nano::genesis_account)); + ASSERT_FALSE (store->block.exists (transaction, send1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (0, ledger.weight (rep.pub)); - ASSERT_EQ (store->account_count (transaction), ledger.cache.account_count); + ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } TEST (ledger, state_receive_change_rollback) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); nano::keypair rep; - nano::state_block receive1 (nano::genesis_account, send1.hash (), rep.pub, nano::genesis_amount, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block receive1 (nano::dev::genesis->account (), send1.hash (), rep.pub, nano::dev::constants.genesis_amount, send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); ASSERT_FALSE (ledger.rollback (transaction, receive1.hash ())); - ASSERT_FALSE (store->block_exists (transaction, receive1.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.account_balance (transaction, nano::genesis_account)); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.weight (nano::genesis_account)); + ASSERT_FALSE (store->block.exists (transaction, receive1.hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.account_balance (transaction, nano::dev::genesis->account ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (0, ledger.weight (rep.pub)); - ASSERT_EQ (store->account_count (transaction), ledger.cache.account_count); + ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } TEST (ledger, epoch_blocks_v1_general) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block epoch1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block epoch1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); ASSERT_FALSE (epoch1.sideband ().details.is_send); ASSERT_FALSE (epoch1.sideband ().details.is_receive); ASSERT_TRUE (epoch1.sideband ().details.is_epoch); ASSERT_EQ (nano::epoch::epoch_1, epoch1.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch1.sideband ().source_epoch); // Not used for epoch blocks - nano::state_block epoch2 (nano::genesis_account, epoch1.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::state_block epoch2 (nano::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, epoch2).code); nano::account_info genesis_info; - ASSERT_FALSE (ledger.store.account_get (transaction, nano::genesis_account, genesis_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, nano::dev::genesis->account (), genesis_info)); ASSERT_EQ (genesis_info.epoch (), nano::epoch::epoch_1); ASSERT_FALSE (ledger.rollback (transaction, epoch1.hash ())); - ASSERT_FALSE (ledger.store.account_get (transaction, nano::genesis_account, genesis_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, nano::dev::genesis->account (), genesis_info)); ASSERT_EQ (genesis_info.epoch (), nano::epoch::epoch_0); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); - ASSERT_FALSE (ledger.store.account_get (transaction, nano::genesis_account, genesis_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, nano::dev::genesis->account (), genesis_info)); ASSERT_EQ (genesis_info.epoch (), nano::epoch::epoch_1); ASSERT_FALSE (epoch1.sideband ().details.is_send); ASSERT_FALSE (epoch1.sideband ().details.is_receive); ASSERT_TRUE (epoch1.sideband ().details.is_epoch); ASSERT_EQ (nano::epoch::epoch_1, epoch1.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch1.sideband ().source_epoch); // Not used for epoch blocks - nano::change_block change1 (epoch1.hash (), nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::change_block change1 (epoch1.hash (), nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, change1).code); - nano::state_block send1 (nano::genesis_account, epoch1.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_TRUE (send1.sideband ().details.is_send); ASSERT_FALSE (send1.sideband ().details.is_receive); ASSERT_FALSE (send1.sideband ().details.is_epoch); ASSERT_EQ (nano::epoch::epoch_1, send1.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, send1.sideband ().source_epoch); // Not used for send blocks - nano::open_block open1 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, open1).code); - nano::state_block epoch3 (destination.pub, 0, nano::genesis_account, 0, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (destination.pub)); + nano::state_block epoch3 (destination.pub, 0, nano::dev::genesis->account (), 0, ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::representative_mismatch, ledger.process (transaction, epoch3).code); - nano::state_block epoch4 (destination.pub, 0, 0, 0, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (destination.pub)); + nano::state_block epoch4 (destination.pub, 0, 0, 0, ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch4).code); ASSERT_FALSE (epoch4.sideband ().details.is_send); ASSERT_FALSE (epoch4.sideband ().details.is_receive); @@ -2436,7 +2248,7 @@ TEST (ledger, epoch_blocks_v1_general) ASSERT_EQ (0, ledger.balance (transaction, epoch4.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.balance (transaction, receive2.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, receive2.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (nano::MBAN_ratio, ledger.weight (destination.pub)); ASSERT_FALSE (receive2.sideband ().details.is_send); ASSERT_TRUE (receive2.sideband ().details.is_receive); @@ -2446,53 +2258,52 @@ TEST (ledger, epoch_blocks_v1_general) TEST (ledger, epoch_blocks_v2_general) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block epoch1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block epoch1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); // Trying to upgrade from epoch 0 to epoch 2. It is a requirement epoch upgrades are sequential unless the account is unopened ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, epoch1).code); // Set it to the first epoch and it should now succeed - epoch1 = nano::state_block (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, epoch1.work); + epoch1 = nano::state_block (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, epoch1.work); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); ASSERT_EQ (nano::epoch::epoch_1, epoch1.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch1.sideband ().source_epoch); // Not used for epoch blocks - nano::state_block epoch2 (nano::genesis_account, epoch1.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::state_block epoch2 (nano::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch2).code); ASSERT_EQ (nano::epoch::epoch_2, epoch2.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch2.sideband ().source_epoch); // Not used for epoch blocks - nano::state_block epoch3 (nano::genesis_account, epoch2.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch2.hash ())); + nano::state_block epoch3 (nano::dev::genesis->account (), epoch2.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch2.hash ())); ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, epoch3).code); nano::account_info genesis_info; - ASSERT_FALSE (ledger.store.account_get (transaction, nano::genesis_account, genesis_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, nano::dev::genesis->account (), genesis_info)); ASSERT_EQ (genesis_info.epoch (), nano::epoch::epoch_2); ASSERT_FALSE (ledger.rollback (transaction, epoch1.hash ())); - ASSERT_FALSE (ledger.store.account_get (transaction, nano::genesis_account, genesis_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, nano::dev::genesis->account (), genesis_info)); ASSERT_EQ (genesis_info.epoch (), nano::epoch::epoch_0); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); - ASSERT_FALSE (ledger.store.account_get (transaction, nano::genesis_account, genesis_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, nano::dev::genesis->account (), genesis_info)); ASSERT_EQ (genesis_info.epoch (), nano::epoch::epoch_1); - nano::change_block change1 (epoch1.hash (), nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::change_block change1 (epoch1.hash (), nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::block_position, ledger.process (transaction, change1).code); - nano::state_block send1 (nano::genesis_account, epoch1.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_EQ (nano::epoch::epoch_1, send1.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, send1.sideband ().source_epoch); // Not used for send blocks - nano::open_block open1 (send1.hash (), nano::genesis_account, destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), destination.pub, destination.prv, destination.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, open1).code); - nano::state_block epoch4 (destination.pub, 0, 0, 0, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (destination.pub)); + nano::state_block epoch4 (destination.pub, 0, 0, 0, ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (destination.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch4).code); ASSERT_EQ (nano::epoch::epoch_1, epoch4.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch4.sideband ().source_epoch); // Not used for epoch blocks - nano::state_block epoch5 (destination.pub, epoch4.hash (), nano::genesis_account, 0, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch4.hash ())); + nano::state_block epoch5 (destination.pub, epoch4.hash (), nano::dev::genesis->account (), 0, ledger.epoch_link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch4.hash ())); ASSERT_EQ (nano::process_result::representative_mismatch, ledger.process (transaction, epoch5).code); - nano::state_block epoch6 (destination.pub, epoch4.hash (), 0, 0, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch4.hash ())); + nano::state_block epoch6 (destination.pub, epoch4.hash (), 0, 0, ledger.epoch_link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch4.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch6).code); ASSERT_EQ (nano::epoch::epoch_2, epoch6.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch6.sideband ().source_epoch); // Not used for epoch blocks @@ -2505,27 +2316,26 @@ TEST (ledger, epoch_blocks_v2_general) ASSERT_EQ (0, ledger.balance (transaction, epoch6.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.balance (transaction, receive2.hash ())); ASSERT_EQ (nano::MBAN_ratio, ledger.amount (transaction, receive2.hash ())); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, ledger.weight (nano::genesis_account)); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.weight (nano::dev::genesis->account ())); ASSERT_EQ (nano::MBAN_ratio, ledger.weight (destination.pub)); } TEST (ledger, epoch_blocks_receive_upgrade) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block epoch1 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block epoch1 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); - nano::state_block send2 (nano::genesis_account, epoch1.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio * 2, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::state_block send2 (nano::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); ASSERT_EQ (nano::epoch::epoch_1, send2.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, send2.sideband ().source_epoch); // Not used for send blocks @@ -2540,20 +2350,20 @@ TEST (ledger, epoch_blocks_receive_upgrade) ASSERT_EQ (nano::epoch::epoch_1, receive2.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_1, receive2.sideband ().source_epoch); nano::account_info destination_info; - ASSERT_FALSE (ledger.store.account_get (transaction, destination.pub, destination_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, destination.pub, destination_info)); ASSERT_EQ (destination_info.epoch (), nano::epoch::epoch_1); ASSERT_FALSE (ledger.rollback (transaction, receive2.hash ())); - ASSERT_FALSE (ledger.store.account_get (transaction, destination.pub, destination_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, destination.pub, destination_info)); ASSERT_EQ (destination_info.epoch (), nano::epoch::epoch_0); nano::pending_info pending_send2; - ASSERT_FALSE (ledger.store.pending_get (transaction, nano::pending_key (destination.pub, send2.hash ()), pending_send2)); - ASSERT_EQ (nano::dev_genesis_key.pub, pending_send2.source); + ASSERT_FALSE (ledger.store.pending.get (transaction, nano::pending_key (destination.pub, send2.hash ()), pending_send2)); + ASSERT_EQ (nano::dev::genesis_key.pub, pending_send2.source); ASSERT_EQ (nano::MBAN_ratio, pending_send2.amount.number ()); ASSERT_EQ (nano::epoch::epoch_1, pending_send2.epoch); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive2).code); ASSERT_EQ (nano::epoch::epoch_1, receive2.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_1, receive2.sideband ().source_epoch); - ASSERT_FALSE (ledger.store.account_get (transaction, destination.pub, destination_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, destination.pub, destination_info)); ASSERT_EQ (destination_info.epoch (), nano::epoch::epoch_1); nano::keypair destination2; nano::state_block send3 (destination.pub, receive2.hash (), destination.pub, nano::MBAN_ratio, destination2.pub, destination.prv, destination.pub, *pool.generate (receive2.hash ())); @@ -2562,57 +2372,56 @@ TEST (ledger, epoch_blocks_receive_upgrade) ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, open2).code); // Upgrade to epoch 2 and send to destination. Try to create an open block from an epoch 2 source block. nano::keypair destination3; - nano::state_block epoch2 (nano::genesis_account, send2.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio * 2, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); + nano::state_block epoch2 (nano::dev::genesis->account (), send2.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, ledger.epoch_link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch2).code); - nano::state_block send4 (nano::genesis_account, epoch2.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio * 3, destination3.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch2.hash ())); + nano::state_block send4 (nano::dev::genesis->account (), epoch2.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio * 3, destination3.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send4).code); nano::open_block open3 (send4.hash (), destination3.pub, destination3.pub, destination3.prv, destination3.pub, *pool.generate (destination3.pub)); ASSERT_EQ (nano::process_result::unreceivable, ledger.process (transaction, open3).code); // Send it to an epoch 1 account - nano::state_block send5 (nano::genesis_account, send4.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio * 4, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send4.hash ())); + nano::state_block send5 (nano::dev::genesis->account (), send4.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio * 4, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send4.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send5).code); - ASSERT_FALSE (ledger.store.account_get (transaction, destination.pub, destination_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, destination.pub, destination_info)); ASSERT_EQ (destination_info.epoch (), nano::epoch::epoch_1); nano::state_block receive3 (destination.pub, send3.hash (), destination.pub, nano::MBAN_ratio * 2, send5.hash (), destination.prv, destination.pub, *pool.generate (send3.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive3).code); ASSERT_EQ (nano::epoch::epoch_2, receive3.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_2, receive3.sideband ().source_epoch); - ASSERT_FALSE (ledger.store.account_get (transaction, destination.pub, destination_info)); + ASSERT_FALSE (ledger.store.account.get (transaction, destination.pub, destination_info)); ASSERT_EQ (destination_info.epoch (), nano::epoch::epoch_2); // Upgrade an unopened account straight to epoch 2 nano::keypair destination4; - nano::state_block send6 (nano::genesis_account, send5.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio * 5, destination4.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send5.hash ())); + nano::state_block send6 (nano::dev::genesis->account (), send5.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio * 5, destination4.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send5.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send6).code); - nano::state_block epoch4 (destination4.pub, 0, 0, 0, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (destination4.pub)); + nano::state_block epoch4 (destination4.pub, 0, 0, 0, ledger.epoch_link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (destination4.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch4).code); ASSERT_EQ (nano::epoch::epoch_2, epoch4.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch4.sideband ().source_epoch); // Not used for epoch blocks - ASSERT_EQ (store->account_count (transaction), ledger.cache.account_count); + ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); } TEST (ledger, epoch_blocks_fork) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; - nano::send_block send1 (genesis.hash (), nano::account (0), nano::genesis_amount, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::send_block send1 (nano::dev::genesis->hash (), nano::account{}, nano::dev::constants.genesis_amount, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::state_block epoch1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block epoch1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, epoch1).code); - nano::state_block epoch2 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::state_block epoch2 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, epoch2).code); - nano::state_block epoch3 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block epoch3 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch3).code); ASSERT_EQ (nano::epoch::epoch_1, epoch3.sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, epoch3.sideband ().source_epoch); // Not used for epoch state blocks - nano::state_block epoch4 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block epoch4 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, ledger.epoch_link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::fork, ledger.process (transaction, epoch2).code); } @@ -2621,14 +2430,13 @@ TEST (ledger, successor_epoch) nano::system system (1); auto & node1 (*system.nodes[0]); nano::keypair key1; - nano::genesis genesis; - nano::work_pool pool (std::numeric_limits::max ()); - nano::send_block send1 (genesis.hash (), key1.pub, nano::genesis_amount - 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::send_block send1 (nano::dev::genesis->hash (), key1.pub, nano::dev::constants.genesis_amount - 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); nano::state_block open (key1.pub, 0, key1.pub, 1, send1.hash (), key1.prv, key1.pub, *pool.generate (key1.pub)); nano::state_block change (key1.pub, open.hash (), key1.pub, 1, 0, key1.prv, key1.pub, *pool.generate (open.hash ())); auto open_hash = open.hash (); - nano::send_block send2 (send1.hash (), reinterpret_cast (open_hash), nano::genesis_amount - 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); - nano::state_block epoch_open (reinterpret_cast (open_hash), 0, 0, 0, node1.ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (open.hash ())); + nano::send_block send2 (send1.hash (), reinterpret_cast (open_hash), nano::dev::constants.genesis_amount - 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block epoch_open (reinterpret_cast (open_hash), 0, 0, 0, node1.ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (open.hash ())); auto transaction (node1.store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, send1).code); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, open).code); @@ -2646,7 +2454,7 @@ TEST (ledger, epoch_open_pending) nano::block_builder builder; nano::system system (1); auto & node1 (*system.nodes[0]); - nano::work_pool pool (std::numeric_limits::max ()); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; auto epoch_open = builder.state () .account (key1.pub) @@ -2654,7 +2462,7 @@ TEST (ledger, epoch_open_pending) .representative (0) .balance (0) .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (key1.pub)) .build_shared (); auto process_result (node1.ledger.process (node1.store.tx_begin_write (), *epoch_open)); @@ -2664,19 +2472,19 @@ TEST (ledger, epoch_open_pending) node1.block_processor.flush (); ASSERT_FALSE (node1.ledger.block_or_pruned_exists (epoch_open->hash ())); // Open block should be inserted into unchecked - auto blocks (node1.store.unchecked_get (node1.store.tx_begin_read (), nano::hash_or_account (epoch_open->account ()).hash)); + auto blocks (node1.store.unchecked.get (node1.store.tx_begin_read (), nano::hash_or_account (epoch_open->account ()).hash)); ASSERT_EQ (blocks.size (), 1); ASSERT_EQ (blocks[0].block->full_hash (), epoch_open->full_hash ()); ASSERT_EQ (blocks[0].verified, nano::signature_verification::valid_epoch); // New block to process epoch open auto send1 = builder.state () - .account (nano::genesis_account) - .previous (nano::genesis_hash) - .representative (nano::genesis_account) - .balance (nano::genesis_amount - 100) + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 100) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*pool.generate (nano::genesis_hash)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) .build_shared (); node1.block_processor.add (send1); node1.block_processor.flush (); @@ -2688,29 +2496,28 @@ TEST (ledger, block_hash_account_conflict) nano::block_builder builder; nano::system system (1); auto & node1 (*system.nodes[0]); - nano::genesis genesis; nano::keypair key1; nano::keypair key2; - nano::work_pool pool (std::numeric_limits::max ()); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; /* * Generate a send block whose destination is a block hash already * in the ledger and not an account */ auto send1 = builder.state () - .account (nano::genesis_account) - .previous (genesis.hash ()) - .representative (nano::genesis_account) - .balance (nano::genesis_amount - 100) + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 100) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*pool.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) .build_shared (); auto receive1 = builder.state () .account (key1.pub) .previous (0) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (100) .link (send1->hash ()) .sign (key1.prv, key1.pub) @@ -2726,7 +2533,7 @@ TEST (ledger, block_hash_account_conflict) auto send2 = builder.state () .account (key1.pub) .previous (receive1->hash ()) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (90) .link (receive1->hash ()) .sign (key1.prv, key1.pub) @@ -2743,7 +2550,7 @@ TEST (ledger, block_hash_account_conflict) .representative (0) .balance (0) .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (receive1->hash ())) .build_shared (); @@ -2777,24 +2584,23 @@ TEST (ledger, block_hash_account_conflict) TEST (ledger, could_fit) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair destination; // Test legacy and state change blocks could_fit - nano::change_block change1 (genesis.hash (), nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); - nano::state_block change2 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + nano::change_block change1 (nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); + nano::state_block change2 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_TRUE (ledger.could_fit (transaction, change1)); ASSERT_TRUE (ledger.could_fit (transaction, change2)); // Test legacy and state send nano::keypair key1; - nano::send_block send1 (change1.hash (), key1.pub, nano::genesis_amount - 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (change1.hash ())); - nano::state_block send2 (nano::genesis_account, change1.hash (), nano::genesis_account, nano::genesis_amount - 1, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (change1.hash ())); + nano::send_block send1 (change1.hash (), key1.pub, nano::dev::constants.genesis_amount - 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (change1.hash ())); + nano::state_block send2 (nano::dev::genesis->account (), change1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 1, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (change1.hash ())); ASSERT_FALSE (ledger.could_fit (transaction, send1)); ASSERT_FALSE (ledger.could_fit (transaction, send2)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change1).code); @@ -2803,8 +2609,8 @@ TEST (ledger, could_fit) ASSERT_TRUE (ledger.could_fit (transaction, send1)); ASSERT_TRUE (ledger.could_fit (transaction, send2)); // Test legacy and state open - nano::open_block open1 (send2.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); - nano::state_block open2 (key1.pub, 0, nano::genesis_account, 1, send2.hash (), key1.prv, key1.pub, *pool.generate (key1.pub)); + nano::open_block open1 (send2.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); + nano::state_block open2 (key1.pub, 0, nano::dev::genesis->account (), 1, send2.hash (), key1.prv, key1.pub, *pool.generate (key1.pub)); ASSERT_FALSE (ledger.could_fit (transaction, open1)); ASSERT_FALSE (ledger.could_fit (transaction, open2)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); @@ -2816,17 +2622,17 @@ TEST (ledger, could_fit) ASSERT_TRUE (ledger.could_fit (transaction, open1)); ASSERT_TRUE (ledger.could_fit (transaction, open2)); // Create another send to receive - nano::state_block send3 (nano::genesis_account, send2.hash (), nano::genesis_account, nano::genesis_amount - 2, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); + nano::state_block send3 (nano::dev::genesis->account (), send2.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 2, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send2.hash ())); // Test legacy and state receive nano::receive_block receive1 (open1.hash (), send3.hash (), key1.prv, key1.pub, *pool.generate (open1.hash ())); - nano::state_block receive2 (key1.pub, open1.hash (), nano::genesis_account, 2, send3.hash (), key1.prv, key1.pub, *pool.generate (open1.hash ())); + nano::state_block receive2 (key1.pub, open1.hash (), nano::dev::genesis->account (), 2, send3.hash (), key1.prv, key1.pub, *pool.generate (open1.hash ())); ASSERT_FALSE (ledger.could_fit (transaction, receive1)); ASSERT_FALSE (ledger.could_fit (transaction, receive2)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send3).code); ASSERT_TRUE (ledger.could_fit (transaction, receive1)); ASSERT_TRUE (ledger.could_fit (transaction, receive2)); // Test epoch (state) - nano::state_block epoch1 (key1.pub, receive1.hash (), nano::genesis_account, 2, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (receive1.hash ())); + nano::state_block epoch1 (key1.pub, receive1.hash (), nano::dev::genesis->account (), 2, ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (receive1.hash ())); ASSERT_FALSE (ledger.could_fit (transaction, epoch1)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); ASSERT_TRUE (ledger.could_fit (transaction, receive1)); @@ -2840,22 +2646,21 @@ TEST (ledger, unchecked_epoch) { nano::system system (1); auto & node1 (*system.nodes[0]); - nano::genesis genesis; nano::keypair destination; - auto send1 (std::make_shared (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send1); auto open1 (std::make_shared (destination.pub, 0, destination.pub, nano::MBAN_ratio, send1->hash (), destination.prv, destination.pub, 0)); node1.work_generate_blocking (*open1); - auto epoch1 (std::make_shared (destination.pub, open1->hash (), destination.pub, nano::MBAN_ratio, node1.ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto epoch1 (std::make_shared (destination.pub, open1->hash (), destination.pub, nano::MBAN_ratio, node1.ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*epoch1); node1.block_processor.add (epoch1); node1.block_processor.flush (); { auto transaction (node1.store.tx_begin_read ()); - auto unchecked_count (node1.store.unchecked_count (transaction)); + auto unchecked_count (node1.store.unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 1); - ASSERT_EQ (unchecked_count, node1.store.unchecked_count (transaction)); - auto blocks (node1.store.unchecked_get (transaction, epoch1->previous ())); + ASSERT_EQ (unchecked_count, node1.store.unchecked.count (transaction)); + auto blocks (node1.store.unchecked.get (transaction, epoch1->previous ())); ASSERT_EQ (blocks.size (), 1); ASSERT_EQ (blocks[0].verified, nano::signature_verification::valid_epoch); } @@ -2864,12 +2669,12 @@ TEST (ledger, unchecked_epoch) node1.block_processor.flush (); { auto transaction (node1.store.tx_begin_read ()); - ASSERT_TRUE (node1.store.block_exists (transaction, epoch1->hash ())); - auto unchecked_count (node1.store.unchecked_count (transaction)); + ASSERT_TRUE (node1.store.block.exists (transaction, epoch1->hash ())); + auto unchecked_count (node1.store.unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 0); - ASSERT_EQ (unchecked_count, node1.store.unchecked_count (transaction)); + ASSERT_EQ (unchecked_count, node1.store.unchecked.count (transaction)); nano::account_info info; - ASSERT_FALSE (node1.store.account_get (transaction, destination.pub, info)); + ASSERT_FALSE (node1.store.account.get (transaction, destination.pub, info)); ASSERT_EQ (info.epoch (), nano::epoch::epoch_1); } } @@ -2880,9 +2685,8 @@ TEST (ledger, unchecked_epoch_invalid) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node1 (*system.add_node (node_config)); - nano::genesis genesis; nano::keypair destination; - auto send1 (std::make_shared (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send1); auto open1 (std::make_shared (destination.pub, 0, destination.pub, nano::MBAN_ratio, send1->hash (), destination.prv, destination.pub, 0)); node1.work_generate_blocking (*open1); @@ -2897,10 +2701,10 @@ TEST (ledger, unchecked_epoch_invalid) node1.block_processor.flush (); { auto transaction (node1.store.tx_begin_read ()); - auto unchecked_count (node1.store.unchecked_count (transaction)); + auto unchecked_count (node1.store.unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 2); - ASSERT_EQ (unchecked_count, node1.store.unchecked_count (transaction)); - auto blocks (node1.store.unchecked_get (transaction, epoch1->previous ())); + ASSERT_EQ (unchecked_count, node1.store.unchecked.count (transaction)); + auto blocks (node1.store.unchecked.get (transaction, epoch1->previous ())); ASSERT_EQ (blocks.size (), 2); ASSERT_EQ (blocks[0].verified, nano::signature_verification::valid); ASSERT_EQ (blocks[1].verified, nano::signature_verification::valid); @@ -2910,16 +2714,16 @@ TEST (ledger, unchecked_epoch_invalid) node1.block_processor.flush (); { auto transaction (node1.store.tx_begin_read ()); - ASSERT_FALSE (node1.store.block_exists (transaction, epoch1->hash ())); - ASSERT_TRUE (node1.store.block_exists (transaction, epoch2->hash ())); + ASSERT_FALSE (node1.store.block.exists (transaction, epoch1->hash ())); + ASSERT_TRUE (node1.store.block.exists (transaction, epoch2->hash ())); ASSERT_TRUE (node1.active.empty ()); - auto unchecked_count (node1.store.unchecked_count (transaction)); + auto unchecked_count (node1.store.unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 0); - ASSERT_EQ (unchecked_count, node1.store.unchecked_count (transaction)); + ASSERT_EQ (unchecked_count, node1.store.unchecked.count (transaction)); nano::account_info info; - ASSERT_FALSE (node1.store.account_get (transaction, destination.pub, info)); + ASSERT_FALSE (node1.store.account.get (transaction, destination.pub, info)); ASSERT_NE (info.epoch (), nano::epoch::epoch_1); - auto epoch2_store (node1.store.block_get (transaction, epoch2->hash ())); + auto epoch2_store (node1.store.block.get (transaction, epoch2->hash ())); ASSERT_NE (nullptr, epoch2_store); ASSERT_EQ (nano::epoch::epoch_0, epoch2_store->sideband ().details.epoch); ASSERT_TRUE (epoch2_store->sideband ().details.is_send); @@ -2932,14 +2736,13 @@ TEST (ledger, unchecked_open) { nano::system system (1); auto & node1 (*system.nodes[0]); - nano::genesis genesis; nano::keypair destination; - auto send1 (std::make_shared (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send1); auto open1 (std::make_shared (send1->hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0)); node1.work_generate_blocking (*open1); // Invalid signature for open block - auto open2 (std::make_shared (send1->hash (), nano::dev_genesis_key.pub, destination.pub, destination.prv, destination.pub, 0)); + auto open2 (std::make_shared (send1->hash (), nano::dev::genesis_key.pub, destination.pub, destination.prv, destination.pub, 0)); node1.work_generate_blocking (*open2); open2->signature.bytes[0] ^= 1; node1.block_processor.add (open1); @@ -2947,10 +2750,10 @@ TEST (ledger, unchecked_open) node1.block_processor.flush (); { auto transaction (node1.store.tx_begin_read ()); - auto unchecked_count (node1.store.unchecked_count (transaction)); + auto unchecked_count (node1.store.unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 1); - ASSERT_EQ (unchecked_count, node1.store.unchecked_count (transaction)); - auto blocks (node1.store.unchecked_get (transaction, open1->source ())); + ASSERT_EQ (unchecked_count, node1.store.unchecked.count (transaction)); + auto blocks (node1.store.unchecked.get (transaction, open1->source ())); ASSERT_EQ (blocks.size (), 1); ASSERT_EQ (blocks[0].verified, nano::signature_verification::valid); } @@ -2958,10 +2761,10 @@ TEST (ledger, unchecked_open) node1.block_processor.flush (); { auto transaction (node1.store.tx_begin_read ()); - ASSERT_TRUE (node1.store.block_exists (transaction, open1->hash ())); - auto unchecked_count (node1.store.unchecked_count (transaction)); + ASSERT_TRUE (node1.store.block.exists (transaction, open1->hash ())); + auto unchecked_count (node1.store.unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 0); - ASSERT_EQ (unchecked_count, node1.store.unchecked_count (transaction)); + ASSERT_EQ (unchecked_count, node1.store.unchecked.count (transaction)); } } @@ -2969,11 +2772,10 @@ TEST (ledger, unchecked_receive) { nano::system system (1); auto & node1 (*system.nodes[0]); - nano::genesis genesis; nano::keypair destination; - auto send1 (std::make_shared (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send1 (std::make_shared (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send1); - auto send2 (std::make_shared (nano::genesis_account, send1->hash (), nano::genesis_account, nano::genesis_amount - 2 * nano::MBAN_ratio, destination.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto send2 (std::make_shared (nano::dev::genesis->account (), send1->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio, destination.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*send2); auto open1 (std::make_shared (send1->hash (), destination.pub, destination.pub, destination.prv, destination.pub, 0)); node1.work_generate_blocking (*open1); @@ -2985,10 +2787,10 @@ TEST (ledger, unchecked_receive) // Previous block for receive1 is unknown, signature cannot be validated { auto transaction (node1.store.tx_begin_read ()); - auto unchecked_count (node1.store.unchecked_count (transaction)); + auto unchecked_count (node1.store.unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 1); - ASSERT_EQ (unchecked_count, node1.store.unchecked_count (transaction)); - auto blocks (node1.store.unchecked_get (transaction, receive1->previous ())); + ASSERT_EQ (unchecked_count, node1.store.unchecked.count (transaction)); + auto blocks (node1.store.unchecked.get (transaction, receive1->previous ())); ASSERT_EQ (blocks.size (), 1); ASSERT_EQ (blocks[0].verified, nano::signature_verification::unknown); } @@ -2997,10 +2799,10 @@ TEST (ledger, unchecked_receive) // Previous block for receive1 is known, signature was validated { auto transaction (node1.store.tx_begin_read ()); - auto unchecked_count (node1.store.unchecked_count (transaction)); + auto unchecked_count (node1.store.unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 1); - ASSERT_EQ (unchecked_count, node1.store.unchecked_count (transaction)); - auto blocks (node1.store.unchecked_get (transaction, receive1->source ())); + ASSERT_EQ (unchecked_count, node1.store.unchecked.count (transaction)); + auto blocks (node1.store.unchecked.get (transaction, receive1->source ())); ASSERT_EQ (blocks.size (), 1); ASSERT_EQ (blocks[0].verified, nano::signature_verification::valid); } @@ -3008,39 +2810,38 @@ TEST (ledger, unchecked_receive) node1.block_processor.flush (); { auto transaction (node1.store.tx_begin_read ()); - ASSERT_TRUE (node1.store.block_exists (transaction, receive1->hash ())); - auto unchecked_count (node1.store.unchecked_count (transaction)); + ASSERT_TRUE (node1.store.block.exists (transaction, receive1->hash ())); + auto unchecked_count (node1.store.unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 0); - ASSERT_EQ (unchecked_count, node1.store.unchecked_count (transaction)); + ASSERT_EQ (unchecked_count, node1.store.unchecked.count (transaction)); } } TEST (ledger, confirmation_height_not_updated) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - nano::genesis genesis; - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::account_info account_info; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, account_info)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, account_info)); nano::keypair key; - nano::send_block send1 (account_info.head, key.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (account_info.head)); + nano::send_block send1 (account_info.head, key.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (account_info.head)); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (store->confirmation_height_get (transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (store->confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); - ASSERT_EQ (genesis.hash (), confirmation_height_info.frontier); + ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_FALSE (store->confirmation_height_get (transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (store->confirmation_height.get (transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (1, confirmation_height_info.height); - ASSERT_EQ (genesis.hash (), confirmation_height_info.frontier); - nano::open_block open1 (send1.hash (), nano::genesis_account, key.pub, key.prv, key.pub, *pool.generate (key.pub)); + ASSERT_EQ (nano::dev::genesis->hash (), confirmation_height_info.frontier); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), key.pub, key.prv, key.pub, *pool.generate (key.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); - ASSERT_TRUE (store->confirmation_height_get (transaction, key.pub, confirmation_height_info)); + ASSERT_TRUE (store->confirmation_height.get (transaction, key.pub, confirmation_height_info)); ASSERT_EQ (0, confirmation_height_info.height); ASSERT_EQ (nano::block_hash (0), confirmation_height_info.frontier); } @@ -3049,54 +2850,52 @@ TEST (ledger, zero_rep) { nano::system system (1); auto & node1 (*system.nodes[0]); - nano::genesis genesis; nano::block_builder builder; auto block1 = builder.state () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) .representative (0) - .balance (nano::genesis_amount) + .balance (nano::dev::constants.genesis_amount) .link (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); auto transaction (node1.store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *block1).code); - ASSERT_EQ (0, node1.ledger.cache.rep_weights.representation_get (nano::dev_genesis_key.pub)); - ASSERT_EQ (nano::genesis_amount, node1.ledger.cache.rep_weights.representation_get (0)); + ASSERT_EQ (0, node1.ledger.cache.rep_weights.representation_get (nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount, node1.ledger.cache.rep_weights.representation_get (0)); auto block2 = builder.state () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (block1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount) .link (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (block1->hash ())) .build (); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *block2).code); - ASSERT_EQ (nano::genesis_amount, node1.ledger.cache.rep_weights.representation_get (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount, node1.ledger.cache.rep_weights.representation_get (nano::dev::genesis_key.pub)); ASSERT_EQ (0, node1.ledger.cache.rep_weights.representation_get (0)); } TEST (ledger, work_validation) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; - store->initialize (store->tx_begin_write (), genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + nano::ledger ledger (*store, stats, nano::dev::constants); + store->initialize (store->tx_begin_write (), ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; - auto gen = nano::dev_genesis_key; + auto gen = nano::dev::genesis_key; nano::keypair key; // With random work the block doesn't pass, then modifies the block with sufficient work and ensures a correct result auto process_block = [&store, &ledger, &pool] (nano::block & block_a, nano::block_details const details_a) { - auto threshold = nano::work_threshold (block_a.work_version (), details_a); + auto threshold = nano::dev::network_params.work.threshold (block_a.work_version (), details_a); // Rarely failed with random work, so modify until it doesn't have enough difficulty - while (block_a.difficulty () >= threshold) + while (nano::dev::network_params.work.difficulty (block_a) >= threshold) { block_a.block_work_set (block_a.block_work () + 1); } @@ -3108,9 +2907,9 @@ TEST (ledger, work_validation) std::error_code ec; auto send = *builder.send () - .previous (nano::genesis_hash) + .previous (nano::dev::genesis->hash ()) .destination (gen.pub) - .balance (nano::genesis_amount - 1) + .balance (nano::dev::constants.genesis_amount - 1) .sign (gen.prv, gen.pub) .work (0) .build (ec); @@ -3136,7 +2935,7 @@ TEST (ledger, work_validation) .account (gen.pub) .previous (change.hash ()) .representative (gen.pub) - .balance (nano::genesis_amount - 1) + .balance (nano::dev::constants.genesis_amount - 1) .link (key.pub) .sign (gen.prv, gen.pub) .work (0) @@ -3175,34 +2974,33 @@ TEST (ledger, dependents_confirmed) { nano::block_builder builder; nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - nano::genesis genesis; - store->initialize (transaction, genesis, ledger.cache); - ASSERT_TRUE (ledger.dependents_confirmed (transaction, *genesis.open)); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + ASSERT_TRUE (ledger.dependents_confirmed (transaction, *nano::dev::genesis)); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; auto send1 = builder.state () - .account (nano::genesis_account) - .previous (genesis.hash ()) - .representative (nano::genesis_account) - .balance (nano::genesis_amount - 100) + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 100) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*pool.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *send1)); auto send2 = builder.state () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (send1->hash ()) - .representative (nano::genesis_account) - .balance (nano::genesis_amount - 200) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 200) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); @@ -3210,7 +3008,7 @@ TEST (ledger, dependents_confirmed) auto receive1 = builder.state () .account (key1.pub) .previous (0) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (100) .link (send1->hash ()) .sign (key1.prv, key1.pub) @@ -3219,14 +3017,14 @@ TEST (ledger, dependents_confirmed) ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive1).code); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive1)); nano::confirmation_height_info height; - ASSERT_FALSE (ledger.store.confirmation_height_get (transaction, nano::genesis_account, height)); + ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); height.height += 1; - ledger.store.confirmation_height_put (transaction, nano::genesis_account, height); + ledger.store.confirmation_height.put (transaction, nano::dev::genesis->account (), height); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *receive1)); auto receive2 = builder.state () .account (key1.pub) .previous (receive1->hash ()) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (200) .link (send2->hash ()) .sign (key1.prv, key1.pub) @@ -3234,13 +3032,13 @@ TEST (ledger, dependents_confirmed) .build_shared (); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *receive2).code); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive2)); - ASSERT_TRUE (ledger.store.confirmation_height_get (transaction, key1.pub, height)); + ASSERT_TRUE (ledger.store.confirmation_height.get (transaction, key1.pub, height)); height.height += 1; - ledger.store.confirmation_height_put (transaction, key1.pub, height); + ledger.store.confirmation_height.put (transaction, key1.pub, height); ASSERT_FALSE (ledger.dependents_confirmed (transaction, *receive2)); - ASSERT_FALSE (ledger.store.confirmation_height_get (transaction, nano::genesis_account, height)); + ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); height.height += 1; - ledger.store.confirmation_height_put (transaction, nano::genesis_account, height); + ledger.store.confirmation_height.put (transaction, nano::dev::genesis->account (), height); ASSERT_TRUE (ledger.dependents_confirmed (transaction, *receive2)); } @@ -3248,46 +3046,45 @@ TEST (ledger, dependents_confirmed_pruning) { nano::block_builder builder; nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); ledger.pruning = true; auto transaction (store->tx_begin_write ()); - nano::genesis genesis; - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; auto send1 = builder.state () - .account (nano::genesis_account) - .previous (genesis.hash ()) - .representative (nano::genesis_account) - .balance (nano::genesis_amount - 100) + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 100) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*pool.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); auto send2 = builder.state () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (send1->hash ()) - .representative (nano::genesis_account) - .balance (nano::genesis_amount - 200) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 200) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (send1->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send2).code); nano::confirmation_height_info height; - ASSERT_FALSE (ledger.store.confirmation_height_get (transaction, nano::genesis_account, height)); + ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); height.height = 3; - ledger.store.confirmation_height_put (transaction, nano::genesis_account, height); + ledger.store.confirmation_height.put (transaction, nano::dev::genesis->account (), height); ASSERT_TRUE (ledger.block_confirmed (transaction, send1->hash ())); ASSERT_EQ (2, ledger.pruning_action (transaction, send2->hash (), 1)); auto receive1 = builder.state () .account (key1.pub) .previous (0) - .representative (nano::genesis_account) + .representative (nano::dev::genesis->account ()) .balance (100) .link (send1->hash ()) .sign (key1.prv, key1.pub) @@ -3300,46 +3097,44 @@ TEST (ledger, block_confirmed) { nano::block_builder builder; nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - nano::genesis genesis; - store->initialize (transaction, genesis, ledger.cache); - ASSERT_TRUE (ledger.block_confirmed (transaction, genesis.open->hash ())); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + ASSERT_TRUE (ledger.block_confirmed (transaction, nano::dev::genesis->hash ())); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key1; auto send1 = builder.state () - .account (nano::genesis_account) - .previous (genesis.hash ()) - .representative (nano::genesis_account) - .balance (nano::genesis_amount - 100) + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 100) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*pool.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) .build (); // Must be safe against non-existing blocks ASSERT_FALSE (ledger.block_confirmed (transaction, send1->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *send1).code); ASSERT_FALSE (ledger.block_confirmed (transaction, send1->hash ())); nano::confirmation_height_info height; - ASSERT_FALSE (ledger.store.confirmation_height_get (transaction, nano::genesis_account, height)); + ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); ++height.height; - ledger.store.confirmation_height_put (transaction, nano::genesis_account, height); + ledger.store.confirmation_height.put (transaction, nano::dev::genesis->account (), height); ASSERT_TRUE (ledger.block_confirmed (transaction, send1->hash ())); } TEST (ledger, cache) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; - store->initialize (store->tx_begin_write (), genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + nano::ledger ledger (*store, stats, nano::dev::constants); + store->initialize (store->tx_begin_write (), ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::block_builder builder; size_t const total = 100; @@ -3350,26 +3145,26 @@ TEST (ledger, cache) auto account_count = 1 + i; auto block_count = 1 + 2 * (i + 1) - 2; auto cemented_count = 1 + 2 * (i + 1) - 2; - auto genesis_weight = nano::genesis_amount - i; + auto genesis_weight = nano::dev::constants.genesis_amount - i; auto pruned_count = i; auto cache_check = [&, i] (nano::ledger_cache const & cache_a) { ASSERT_EQ (account_count, cache_a.account_count); ASSERT_EQ (block_count, cache_a.block_count); ASSERT_EQ (cemented_count, cache_a.cemented_count); - ASSERT_EQ (genesis_weight, cache_a.rep_weights.representation_get (nano::genesis_account)); + ASSERT_EQ (genesis_weight, cache_a.rep_weights.representation_get (nano::dev::genesis->account ())); ASSERT_EQ (pruned_count, cache_a.pruned_count); }; nano::keypair key; - auto const latest = ledger.latest (store->tx_begin_read (), nano::genesis_account); + auto const latest = ledger.latest (store->tx_begin_read (), nano::dev::genesis->account ()); auto send = builder.state () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (latest) - .representative (nano::genesis_account) - .balance (nano::genesis_amount - (i + 1)) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - (i + 1)) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (latest)) .build (); auto open = builder.state () @@ -3389,7 +3184,7 @@ TEST (ledger, cache) ++block_count; --genesis_weight; cache_check (ledger.cache); - cache_check (nano::ledger (*store, stats).cache); + cache_check (nano::ledger (*store, stats, nano::dev::constants).cache); { auto transaction (store->tx_begin_write ()); @@ -3399,191 +3194,188 @@ TEST (ledger, cache) ++block_count; ++account_count; cache_check (ledger.cache); - cache_check (nano::ledger (*store, stats).cache); + cache_check (nano::ledger (*store, stats, nano::dev::constants).cache); { auto transaction (store->tx_begin_write ()); nano::confirmation_height_info height; - ASSERT_FALSE (ledger.store.confirmation_height_get (transaction, nano::genesis_account, height)); + ASSERT_FALSE (ledger.store.confirmation_height.get (transaction, nano::dev::genesis->account (), height)); ++height.height; height.frontier = send->hash (); - ledger.store.confirmation_height_put (transaction, nano::genesis_account, height); + ledger.store.confirmation_height.put (transaction, nano::dev::genesis->account (), height); ASSERT_TRUE (ledger.block_confirmed (transaction, send->hash ())); ++ledger.cache.cemented_count; } ++cemented_count; cache_check (ledger.cache); - cache_check (nano::ledger (*store, stats).cache); + cache_check (nano::ledger (*store, stats, nano::dev::constants).cache); { auto transaction (store->tx_begin_write ()); nano::confirmation_height_info height; - ledger.store.confirmation_height_get (transaction, key.pub, height); + ledger.store.confirmation_height.get (transaction, key.pub, height); height.height += 1; height.frontier = open->hash (); - ledger.store.confirmation_height_put (transaction, key.pub, height); + ledger.store.confirmation_height.put (transaction, key.pub, height); ASSERT_TRUE (ledger.block_confirmed (transaction, open->hash ())); ++ledger.cache.cemented_count; } ++cemented_count; cache_check (ledger.cache); - cache_check (nano::ledger (*store, stats).cache); + cache_check (nano::ledger (*store, stats, nano::dev::constants).cache); { auto transaction (store->tx_begin_write ()); - ledger.store.pruned_put (transaction, open->hash ()); + ledger.store.pruned.put (transaction, open->hash ()); ++ledger.cache.pruned_count; } ++pruned_count; cache_check (ledger.cache); - cache_check (nano::ledger (*store, stats).cache); + cache_check (nano::ledger (*store, stats, nano::dev::constants).cache); } } TEST (ledger, pruning_action) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); ledger.pruning = true; - nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->block_exists (transaction, send1.hash ())); - auto send1_stored (store->block_get (transaction, send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); + auto send1_stored (store->block.get (transaction, send1.hash ())); ASSERT_NE (nullptr, send1_stored); ASSERT_EQ (send1, *send1_stored); - ASSERT_TRUE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); - nano::state_block send2 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio * 2, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); + nano::state_block send2 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); - ASSERT_TRUE (store->block_exists (transaction, send2.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); // Pruning action ASSERT_EQ (1, ledger.pruning_action (transaction, send1.hash (), 1)); - ASSERT_EQ (0, ledger.pruning_action (transaction, genesis.hash (), 1)); - ASSERT_TRUE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); - ASSERT_FALSE (store->block_exists (transaction, send1.hash ())); + ASSERT_EQ (0, ledger.pruning_action (transaction, nano::dev::genesis->hash (), 1)); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); + ASSERT_FALSE (store->block.exists (transaction, send1.hash ())); ASSERT_TRUE (ledger.block_or_pruned_exists (transaction, send1.hash ())); // Pruned ledger start without proper flags emulation ledger.pruning = false; ASSERT_TRUE (ledger.block_or_pruned_exists (transaction, send1.hash ())); ledger.pruning = true; - ASSERT_TRUE (store->pruned_exists (transaction, send1.hash ())); - ASSERT_TRUE (store->block_exists (transaction, genesis.hash ())); - ASSERT_TRUE (store->block_exists (transaction, send2.hash ())); + ASSERT_TRUE (store->pruned.exists (transaction, send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, nano::dev::genesis->hash ())); + ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); // Receiving pruned block - nano::state_block receive1 (nano::genesis_account, send2.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); + nano::state_block receive1 (nano::dev::genesis->account (), send2.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_TRUE (store->block_exists (transaction, receive1.hash ())); - auto receive1_stored (store->block_get (transaction, receive1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, receive1.hash ())); + auto receive1_stored (store->block.get (transaction, receive1.hash ())); ASSERT_NE (nullptr, receive1_stored); ASSERT_EQ (receive1, *receive1_stored); - ASSERT_FALSE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_EQ (4, receive1_stored->sideband ().height); ASSERT_FALSE (receive1_stored->sideband ().details.is_send); ASSERT_TRUE (receive1_stored->sideband ().details.is_receive); ASSERT_FALSE (receive1_stored->sideband ().details.is_epoch); // Middle block pruning - ASSERT_TRUE (store->block_exists (transaction, send2.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); ASSERT_EQ (1, ledger.pruning_action (transaction, send2.hash (), 1)); - ASSERT_TRUE (store->pruned_exists (transaction, send2.hash ())); - ASSERT_FALSE (store->block_exists (transaction, send2.hash ())); - ASSERT_EQ (store->account_count (transaction), ledger.cache.account_count); - ASSERT_EQ (store->pruned_count (transaction), ledger.cache.pruned_count); - ASSERT_EQ (store->block_count (transaction), ledger.cache.block_count - ledger.cache.pruned_count); + ASSERT_TRUE (store->pruned.exists (transaction, send2.hash ())); + ASSERT_FALSE (store->block.exists (transaction, send2.hash ())); + ASSERT_EQ (store->account.count (transaction), ledger.cache.account_count); + ASSERT_EQ (store->pruned.count (transaction), ledger.cache.pruned_count); + ASSERT_EQ (store->block.count (transaction), ledger.cache.block_count - ledger.cache.pruned_count); } TEST (ledger, pruning_large_chain) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); ledger.pruning = true; - nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; size_t send_receive_pairs (20); - auto last_hash (genesis.hash ()); + auto last_hash (nano::dev::genesis->hash ()); for (auto i (0); i < send_receive_pairs; i++) { - nano::state_block send (nano::genesis_account, last_hash, nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (last_hash)); + nano::state_block send (nano::dev::genesis->account (), last_hash, nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (last_hash)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); - ASSERT_TRUE (store->block_exists (transaction, send.hash ())); - nano::state_block receive (nano::genesis_account, send.hash (), nano::genesis_account, nano::genesis_amount, send.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send.hash ())); + nano::state_block receive (nano::dev::genesis->account (), send.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, send.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code); - ASSERT_TRUE (store->block_exists (transaction, receive.hash ())); + ASSERT_TRUE (store->block.exists (transaction, receive.hash ())); last_hash = receive.hash (); } - ASSERT_EQ (0, store->pruned_count (transaction)); - ASSERT_EQ (send_receive_pairs * 2 + 1, store->block_count (transaction)); + ASSERT_EQ (0, store->pruned.count (transaction)); + ASSERT_EQ (send_receive_pairs * 2 + 1, store->block.count (transaction)); // Pruning action ASSERT_EQ (send_receive_pairs * 2, ledger.pruning_action (transaction, last_hash, 5)); - ASSERT_TRUE (store->pruned_exists (transaction, last_hash)); - ASSERT_TRUE (store->block_exists (transaction, genesis.hash ())); - ASSERT_FALSE (store->block_exists (transaction, last_hash)); - ASSERT_EQ (store->pruned_count (transaction), ledger.cache.pruned_count); - ASSERT_EQ (store->block_count (transaction), ledger.cache.block_count - ledger.cache.pruned_count); - ASSERT_EQ (send_receive_pairs * 2, store->pruned_count (transaction)); - ASSERT_EQ (1, store->block_count (transaction)); // Genesis + ASSERT_TRUE (store->pruned.exists (transaction, last_hash)); + ASSERT_TRUE (store->block.exists (transaction, nano::dev::genesis->hash ())); + ASSERT_FALSE (store->block.exists (transaction, last_hash)); + ASSERT_EQ (store->pruned.count (transaction), ledger.cache.pruned_count); + ASSERT_EQ (store->block.count (transaction), ledger.cache.block_count - ledger.cache.pruned_count); + ASSERT_EQ (send_receive_pairs * 2, store->pruned.count (transaction)); + ASSERT_EQ (1, store->block.count (transaction)); // Genesis } TEST (ledger, pruning_source_rollback) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); ledger.pruning = true; - nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block epoch1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block epoch1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, ledger.epoch_link (nano::epoch::epoch_1), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, epoch1).code); - nano::state_block send1 (nano::genesis_account, epoch1.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (epoch1.hash ())); + nano::state_block send1 (nano::dev::genesis->account (), epoch1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (epoch1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); - nano::state_block send2 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio * 2, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); + nano::state_block send2 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); - ASSERT_TRUE (store->block_exists (transaction, send2.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); // Pruning action ASSERT_EQ (2, ledger.pruning_action (transaction, send1.hash (), 1)); - ASSERT_FALSE (store->block_exists (transaction, send1.hash ())); - ASSERT_TRUE (store->pruned_exists (transaction, send1.hash ())); - ASSERT_FALSE (store->block_exists (transaction, epoch1.hash ())); - ASSERT_TRUE (store->pruned_exists (transaction, epoch1.hash ())); - ASSERT_TRUE (store->block_exists (transaction, genesis.hash ())); + ASSERT_FALSE (store->block.exists (transaction, send1.hash ())); + ASSERT_TRUE (store->pruned.exists (transaction, send1.hash ())); + ASSERT_FALSE (store->block.exists (transaction, epoch1.hash ())); + ASSERT_TRUE (store->pruned.exists (transaction, epoch1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, nano::dev::genesis->hash ())); nano::pending_info info; - ASSERT_FALSE (store->pending_get (transaction, nano::pending_key (nano::genesis_account, send1.hash ()), info)); - ASSERT_EQ (nano::genesis_account, info.source); + ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info)); + ASSERT_EQ (nano::dev::genesis->account (), info.source); ASSERT_EQ (nano::MBAN_ratio, info.amount.number ()); ASSERT_EQ (nano::epoch::epoch_1, info.epoch); // Receiving pruned block - nano::state_block receive1 (nano::genesis_account, send2.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); + nano::state_block receive1 (nano::dev::genesis->account (), send2.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_FALSE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); // Rollback receive block ASSERT_FALSE (ledger.rollback (transaction, receive1.hash ())); nano::pending_info info2; - ASSERT_FALSE (store->pending_get (transaction, nano::pending_key (nano::genesis_account, send1.hash ()), info2)); - ASSERT_NE (nano::genesis_account, info2.source); // Tradeoff to not store pruned blocks accounts + ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info2)); + ASSERT_NE (nano::dev::genesis->account (), info2.source); // Tradeoff to not store pruned blocks accounts ASSERT_EQ (nano::MBAN_ratio, info2.amount.number ()); ASSERT_EQ (nano::epoch::epoch_1, info2.epoch); // Process receive block again ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_FALSE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); } @@ -3591,78 +3383,77 @@ TEST (ledger, pruning_source_rollback) TEST (ledger, pruning_source_rollback_legacy) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); ledger.pruning = true; - nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::send_block send1 (nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); nano::keypair key1; - nano::send_block send2 (send1.hash (), key1.pub, nano::genesis_amount - 2 * nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::send_block send2 (send1.hash (), key1.pub, nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); - ASSERT_TRUE (store->block_exists (transaction, send2.hash ())); - ASSERT_TRUE (store->pending_exists (transaction, nano::pending_key (key1.pub, send2.hash ()))); - nano::send_block send3 (send2.hash (), nano::genesis_account, nano::genesis_amount - 3 * nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send2.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (key1.pub, send2.hash ()))); + nano::send_block send3 (send2.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - 3 * nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send3).code); - ASSERT_TRUE (store->block_exists (transaction, send3.hash ())); - ASSERT_TRUE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send3.hash ()))); + ASSERT_TRUE (store->block.exists (transaction, send3.hash ())); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send3.hash ()))); // Pruning action ASSERT_EQ (2, ledger.pruning_action (transaction, send2.hash (), 1)); - ASSERT_FALSE (store->block_exists (transaction, send2.hash ())); - ASSERT_TRUE (store->pruned_exists (transaction, send2.hash ())); - ASSERT_FALSE (store->block_exists (transaction, send1.hash ())); - ASSERT_TRUE (store->pruned_exists (transaction, send1.hash ())); - ASSERT_TRUE (store->block_exists (transaction, genesis.hash ())); + ASSERT_FALSE (store->block.exists (transaction, send2.hash ())); + ASSERT_TRUE (store->pruned.exists (transaction, send2.hash ())); + ASSERT_FALSE (store->block.exists (transaction, send1.hash ())); + ASSERT_TRUE (store->pruned.exists (transaction, send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, nano::dev::genesis->hash ())); nano::pending_info info1; - ASSERT_FALSE (store->pending_get (transaction, nano::pending_key (nano::genesis_account, send1.hash ()), info1)); - ASSERT_EQ (nano::genesis_account, info1.source); + ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info1)); + ASSERT_EQ (nano::dev::genesis->account (), info1.source); ASSERT_EQ (nano::MBAN_ratio, info1.amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info1.epoch); nano::pending_info info2; - ASSERT_FALSE (store->pending_get (transaction, nano::pending_key (key1.pub, send2.hash ()), info2)); - ASSERT_EQ (nano::genesis_account, info2.source); + ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (key1.pub, send2.hash ()), info2)); + ASSERT_EQ (nano::dev::genesis->account (), info2.source); ASSERT_EQ (nano::MBAN_ratio, info2.amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info2.epoch); // Receiving pruned block - nano::receive_block receive1 (send3.hash (), send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send3.hash ())); + nano::receive_block receive1 (send3.hash (), send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send3.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_FALSE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); // Rollback receive block ASSERT_FALSE (ledger.rollback (transaction, receive1.hash ())); nano::pending_info info3; - ASSERT_FALSE (store->pending_get (transaction, nano::pending_key (nano::genesis_account, send1.hash ()), info3)); - ASSERT_NE (nano::genesis_account, info3.source); // Tradeoff to not store pruned blocks accounts + ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()), info3)); + ASSERT_NE (nano::dev::genesis->account (), info3.source); // Tradeoff to not store pruned blocks accounts ASSERT_EQ (nano::MBAN_ratio, info3.amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info3.epoch); // Process receive block again ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - ASSERT_FALSE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (5, ledger.cache.block_count); // Receiving pruned block (open) - nano::open_block open1 (send2.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); + nano::open_block open1 (send2.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); - ASSERT_FALSE (store->pending_exists (transaction, nano::pending_key (key1.pub, send2.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (key1.pub, send2.hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (6, ledger.cache.block_count); // Rollback open block ASSERT_FALSE (ledger.rollback (transaction, open1.hash ())); nano::pending_info info4; - ASSERT_FALSE (store->pending_get (transaction, nano::pending_key (key1.pub, send2.hash ()), info4)); - ASSERT_NE (nano::genesis_account, info4.source); // Tradeoff to not store pruned blocks accounts + ASSERT_FALSE (store->pending.get (transaction, nano::pending_key (key1.pub, send2.hash ()), info4)); + ASSERT_NE (nano::dev::genesis->account (), info4.source); // Tradeoff to not store pruned blocks accounts ASSERT_EQ (nano::MBAN_ratio, info4.amount.number ()); ASSERT_EQ (nano::epoch::epoch_0, info4.epoch); // Process open block again ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); - ASSERT_FALSE (store->pending_exists (transaction, nano::pending_key (key1.pub, send2.hash ()))); + ASSERT_FALSE (store->pending.exists (transaction, nano::pending_key (key1.pub, send2.hash ()))); ASSERT_EQ (2, ledger.cache.pruned_count); ASSERT_EQ (6, ledger.cache.block_count); } @@ -3670,27 +3461,26 @@ TEST (ledger, pruning_source_rollback_legacy) TEST (ledger, pruning_process_error) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); ledger.pruning = true; - nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); ASSERT_EQ (0, ledger.cache.pruned_count); ASSERT_EQ (2, ledger.cache.block_count); // Pruning action for latest block (not valid action) ASSERT_EQ (1, ledger.pruning_action (transaction, send1.hash (), 1)); - ASSERT_FALSE (store->block_exists (transaction, send1.hash ())); - ASSERT_TRUE (store->pruned_exists (transaction, send1.hash ())); + ASSERT_FALSE (store->block.exists (transaction, send1.hash ())); + ASSERT_TRUE (store->pruned.exists (transaction, send1.hash ())); // Attempt to process pruned block again ASSERT_EQ (nano::process_result::old, ledger.process (transaction, send1).code); // Attept to process new block after pruned - nano::state_block send2 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio * 2, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + nano::state_block send2 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::gap_previous, ledger.process (transaction, send2).code); ASSERT_EQ (1, ledger.cache.pruned_count); ASSERT_EQ (2, ledger.cache.block_count); @@ -3699,80 +3489,78 @@ TEST (ledger, pruning_process_error) TEST (ledger, pruning_legacy_blocks) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); ledger.pruning = true; - nano::genesis genesis; nano::keypair key1; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::send_block send1 (genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::send_block send1 (nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->pending_exists (transaction, nano::pending_key (nano::genesis_account, send1.hash ()))); - nano::receive_block receive1 (send1.hash (), send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + ASSERT_TRUE (store->pending.exists (transaction, nano::pending_key (nano::dev::genesis->account (), send1.hash ()))); + nano::receive_block receive1 (send1.hash (), send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive1).code); - nano::change_block change1 (receive1.hash (), key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (receive1.hash ())); + nano::change_block change1 (receive1.hash (), key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (receive1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change1).code); - nano::send_block send2 (change1.hash (), key1.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (change1.hash ())); + nano::send_block send2 (change1.hash (), key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (change1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); - nano::open_block open1 (send2.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); + nano::open_block open1 (send2.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *pool.generate (key1.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open1).code); - nano::send_block send3 (open1.hash (), nano::genesis_account, 0, key1.prv, key1.pub, *pool.generate (open1.hash ())); + nano::send_block send3 (open1.hash (), nano::dev::genesis->account (), 0, key1.prv, key1.pub, *pool.generate (open1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send3).code); // Pruning action ASSERT_EQ (3, ledger.pruning_action (transaction, change1.hash (), 2)); ASSERT_EQ (1, ledger.pruning_action (transaction, open1.hash (), 1)); - ASSERT_TRUE (store->block_exists (transaction, genesis.hash ())); - ASSERT_FALSE (store->block_exists (transaction, send1.hash ())); - ASSERT_TRUE (store->pruned_exists (transaction, send1.hash ())); - ASSERT_FALSE (store->block_exists (transaction, receive1.hash ())); - ASSERT_TRUE (store->pruned_exists (transaction, receive1.hash ())); - ASSERT_FALSE (store->block_exists (transaction, change1.hash ())); - ASSERT_TRUE (store->pruned_exists (transaction, change1.hash ())); - ASSERT_TRUE (store->block_exists (transaction, send2.hash ())); - ASSERT_FALSE (store->block_exists (transaction, open1.hash ())); - ASSERT_TRUE (store->pruned_exists (transaction, open1.hash ())); - ASSERT_TRUE (store->block_exists (transaction, send3.hash ())); + ASSERT_TRUE (store->block.exists (transaction, nano::dev::genesis->hash ())); + ASSERT_FALSE (store->block.exists (transaction, send1.hash ())); + ASSERT_TRUE (store->pruned.exists (transaction, send1.hash ())); + ASSERT_FALSE (store->block.exists (transaction, receive1.hash ())); + ASSERT_TRUE (store->pruned.exists (transaction, receive1.hash ())); + ASSERT_FALSE (store->block.exists (transaction, change1.hash ())); + ASSERT_TRUE (store->pruned.exists (transaction, change1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); + ASSERT_FALSE (store->block.exists (transaction, open1.hash ())); + ASSERT_TRUE (store->pruned.exists (transaction, open1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send3.hash ())); ASSERT_EQ (4, ledger.cache.pruned_count); ASSERT_EQ (7, ledger.cache.block_count); - ASSERT_EQ (store->pruned_count (transaction), ledger.cache.pruned_count); - ASSERT_EQ (store->block_count (transaction), ledger.cache.block_count - ledger.cache.pruned_count); + ASSERT_EQ (store->pruned.count (transaction), ledger.cache.pruned_count); + ASSERT_EQ (store->block.count (transaction), ledger.cache.block_count - ledger.cache.pruned_count); } TEST (ledger, pruning_safe_functions) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); ledger.pruning = true; - nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->block_exists (transaction, send1.hash ())); - nano::state_block send2 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio * 2, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); + nano::state_block send2 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); - ASSERT_TRUE (store->block_exists (transaction, send2.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); // Pruning action ASSERT_EQ (1, ledger.pruning_action (transaction, send1.hash (), 1)); - ASSERT_FALSE (store->block_exists (transaction, send1.hash ())); + ASSERT_FALSE (store->block.exists (transaction, send1.hash ())); ASSERT_TRUE (ledger.block_or_pruned_exists (transaction, send1.hash ())); // true for pruned - ASSERT_TRUE (store->pruned_exists (transaction, send1.hash ())); - ASSERT_TRUE (store->block_exists (transaction, genesis.hash ())); - ASSERT_TRUE (store->block_exists (transaction, send2.hash ())); + ASSERT_TRUE (store->pruned.exists (transaction, send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, nano::dev::genesis->hash ())); + ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); // Safe ledger actions bool error (false); ASSERT_EQ (0, ledger.balance_safe (transaction, send1.hash (), error)); ASSERT_TRUE (error); error = false; - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio * 2, ledger.balance_safe (transaction, send2.hash (), error)); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, ledger.balance_safe (transaction, send2.hash (), error)); ASSERT_FALSE (error); error = false; ASSERT_EQ (0, ledger.amount_safe (transaction, send2.hash (), error)); @@ -3781,34 +3569,33 @@ TEST (ledger, pruning_safe_functions) ASSERT_TRUE (ledger.account_safe (transaction, send1.hash (), error).is_zero ()); ASSERT_TRUE (error); error = false; - ASSERT_EQ (nano::genesis_account, ledger.account_safe (transaction, send2.hash (), error)); + ASSERT_EQ (nano::dev::genesis->account (), ledger.account_safe (transaction, send2.hash (), error)); ASSERT_FALSE (error); } TEST (ledger, hash_root_random) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); ledger.pruning = true; - nano::genesis genesis; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); - nano::state_block send1 (nano::genesis_account, genesis.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + nano::state_block send1 (nano::dev::genesis->account (), nano::dev::genesis->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - ASSERT_TRUE (store->block_exists (transaction, send1.hash ())); - nano::state_block send2 (nano::genesis_account, send1.hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio * 2, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send1.hash ())); + nano::state_block send2 (nano::dev::genesis->account (), send1.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio * 2, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); - ASSERT_TRUE (store->block_exists (transaction, send2.hash ())); + ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); // Pruning action ASSERT_EQ (1, ledger.pruning_action (transaction, send1.hash (), 1)); - ASSERT_FALSE (store->block_exists (transaction, send1.hash ())); - ASSERT_TRUE (store->pruned_exists (transaction, send1.hash ())); - ASSERT_TRUE (store->block_exists (transaction, genesis.hash ())); - ASSERT_TRUE (store->block_exists (transaction, send2.hash ())); + ASSERT_FALSE (store->block.exists (transaction, send1.hash ())); + ASSERT_TRUE (store->pruned.exists (transaction, send1.hash ())); + ASSERT_TRUE (store->block.exists (transaction, nano::dev::genesis->hash ())); + ASSERT_TRUE (store->block.exists (transaction, send2.hash ())); // Test random block including pruned bool done (false); auto iteration (0); @@ -3832,23 +3619,22 @@ TEST (ledger, hash_root_random) TEST (ledger, migrate_lmdb_to_rocksdb) { auto path (nano::unique_path ()); - nano::genesis genesis; nano::logger_mt logger; boost::asio::ip::address_v6 address (boost::asio::ip::make_address_v6 ("::ffff:127.0.0.1")); uint16_t port = 100; - nano::mdb_store store (logger, path / "data.ldb"); + nano::mdb_store store (logger, path / "data.ldb", nano::dev::constants); nano::stat stats; - nano::ledger ledger (store, stats); - nano::work_pool pool (std::numeric_limits::max ()); + nano::ledger ledger (store, stats, nano::dev::constants); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; auto send = nano::state_block_builder () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) .representative (0) .link (nano::account (10)) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*pool.generate (nano::genesis_hash)) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*pool.generate (nano::dev::genesis->hash ())) .build_shared (); nano::endpoint_key endpoint_key (address.to_bytes (), port); @@ -3856,85 +3642,84 @@ TEST (ledger, migrate_lmdb_to_rocksdb) { auto transaction (store.tx_begin_write ()); - store.initialize (transaction, genesis, ledger.cache); + store.initialize (transaction, ledger.cache); ASSERT_FALSE (store.init_error ()); // Lower the database to the max version unsupported for upgrades - store.confirmation_height_put (transaction, nano::genesis_account, { 2, send->hash () }); + store.confirmation_height.put (transaction, nano::dev::genesis->account (), { 2, send->hash () }); - store.online_weight_put (transaction, 100, nano::amount (2)); - store.frontier_put (transaction, nano::block_hash (2), nano::account (5)); - store.peer_put (transaction, endpoint_key); + store.online_weight.put (transaction, 100, nano::amount (2)); + store.frontier.put (transaction, nano::block_hash (2), nano::account (5)); + store.peer.put (transaction, endpoint_key); - store.pending_put (transaction, nano::pending_key (nano::genesis_account, send->hash ()), nano::pending_info (nano::genesis_account, 100, nano::epoch::epoch_0)); - store.pruned_put (transaction, send->hash ()); - store.unchecked_put (transaction, nano::genesis_hash, send); - store.version_put (transaction, version); + store.pending.put (transaction, nano::pending_key (nano::dev::genesis->account (), send->hash ()), nano::pending_info (nano::dev::genesis->account (), 100, nano::epoch::epoch_0)); + store.pruned.put (transaction, send->hash ()); + store.unchecked.put (transaction, nano::dev::genesis->hash (), send); + store.version.put (transaction, version); send->sideband_set ({}); - store.block_put (transaction, send->hash (), *send); - store.final_vote_put (transaction, send->qualified_root (), nano::block_hash (2)); + store.block.put (transaction, send->hash (), *send); + store.final_vote.put (transaction, send->qualified_root (), nano::block_hash (2)); } auto error = ledger.migrate_lmdb_to_rocksdb (path); ASSERT_FALSE (error); - nano::rocksdb_store rocksdb_store (logger, path / "rocksdb"); + nano::rocksdb_store rocksdb_store (logger, path / "rocksdb", nano::dev::constants); auto rocksdb_transaction (rocksdb_store.tx_begin_read ()); nano::pending_info pending_info; - ASSERT_FALSE (rocksdb_store.pending_get (rocksdb_transaction, nano::pending_key (nano::genesis_account, send->hash ()), pending_info)); + ASSERT_FALSE (rocksdb_store.pending.get (rocksdb_transaction, nano::pending_key (nano::dev::genesis->account (), send->hash ()), pending_info)); - for (auto i = rocksdb_store.online_weight_begin (rocksdb_transaction); i != rocksdb_store.online_weight_end (); ++i) + for (auto i = rocksdb_store.online_weight.begin (rocksdb_transaction); i != rocksdb_store.online_weight.end (); ++i) { ASSERT_EQ (i->first, 100); ASSERT_EQ (i->second, 2); } - ASSERT_EQ (rocksdb_store.online_weight_count (rocksdb_transaction), 1); + ASSERT_EQ (rocksdb_store.online_weight.count (rocksdb_transaction), 1); - auto block1 = rocksdb_store.block_get (rocksdb_transaction, send->hash ()); + auto block1 = rocksdb_store.block.get (rocksdb_transaction, send->hash ()); ASSERT_EQ (*send, *block1); - ASSERT_TRUE (rocksdb_store.peer_exists (rocksdb_transaction, endpoint_key)); - ASSERT_EQ (rocksdb_store.version_get (rocksdb_transaction), version); - ASSERT_EQ (rocksdb_store.frontier_get (rocksdb_transaction, 2), 5); + ASSERT_TRUE (rocksdb_store.peer.exists (rocksdb_transaction, endpoint_key)); + ASSERT_EQ (rocksdb_store.version.get (rocksdb_transaction), version); + ASSERT_EQ (rocksdb_store.frontier.get (rocksdb_transaction, 2), 5); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (rocksdb_store.confirmation_height_get (rocksdb_transaction, nano::genesis_account, confirmation_height_info)); + ASSERT_FALSE (rocksdb_store.confirmation_height.get (rocksdb_transaction, nano::dev::genesis->account (), confirmation_height_info)); ASSERT_EQ (confirmation_height_info.height, 2); ASSERT_EQ (confirmation_height_info.frontier, send->hash ()); - ASSERT_TRUE (rocksdb_store.final_vote_get (rocksdb_transaction, nano::root (send->previous ())).size () == 1); - ASSERT_EQ (rocksdb_store.final_vote_get (rocksdb_transaction, nano::root (send->previous ()))[0], nano::block_hash (2)); + ASSERT_TRUE (rocksdb_store.final_vote.get (rocksdb_transaction, nano::root (send->previous ())).size () == 1); + ASSERT_EQ (rocksdb_store.final_vote.get (rocksdb_transaction, nano::root (send->previous ()))[0], nano::block_hash (2)); - auto unchecked_infos = rocksdb_store.unchecked_get (rocksdb_transaction, nano::genesis_hash); + auto unchecked_infos = rocksdb_store.unchecked.get (rocksdb_transaction, nano::dev::genesis->hash ()); ASSERT_EQ (unchecked_infos.size (), 1); - ASSERT_EQ (unchecked_infos.front ().account, nano::genesis_account); + ASSERT_EQ (unchecked_infos.front ().account, nano::dev::genesis->account ()); ASSERT_EQ (*unchecked_infos.front ().block, *send); } TEST (ledger, unconfirmed_frontiers) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; - store->initialize (store->tx_begin_write (), genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + nano::ledger ledger (*store, stats, nano::dev::constants); + store->initialize (store->tx_begin_write (), ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; auto unconfirmed_frontiers = ledger.unconfirmed_frontiers (); ASSERT_TRUE (unconfirmed_frontiers.empty ()); nano::state_block_builder builder; nano::keypair key; - auto const latest = ledger.latest (store->tx_begin_read (), nano::genesis_account); + auto const latest = ledger.latest (store->tx_begin_read (), nano::dev::genesis->account ()); auto send = builder.make_block () - .account (nano::genesis_account) + .account (nano::dev::genesis->account ()) .previous (latest) - .representative (nano::genesis_account) - .balance (nano::genesis_amount - 100) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - 100) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*pool.generate (latest)) .build (); @@ -3943,7 +3728,7 @@ TEST (ledger, unconfirmed_frontiers) unconfirmed_frontiers = ledger.unconfirmed_frontiers (); ASSERT_EQ (unconfirmed_frontiers.size (), 1); ASSERT_EQ (unconfirmed_frontiers.begin ()->first, 1); - nano::uncemented_info uncemented_info1{ latest, send->hash (), nano::genesis_account }; + nano::uncemented_info uncemented_info1{ latest, send->hash (), nano::dev::genesis->account () }; auto uncemented_info2 = unconfirmed_frontiers.begin ()->second; ASSERT_EQ (uncemented_info1.account, uncemented_info2.account); ASSERT_EQ (uncemented_info1.cemented_frontier, uncemented_info2.cemented_frontier); diff --git a/nano/core_test/ledger_walker.cpp b/nano/core_test/ledger_walker.cpp new file mode 100644 index 0000000000..0ca3b39af1 --- /dev/null +++ b/nano/core_test/ledger_walker.cpp @@ -0,0 +1,224 @@ +#include +#include +#include + +#include + +#include + +// TODO: keep this until diskhash builds fine on Windows +#ifndef _WIN32 + +using namespace std::chrono_literals; + +TEST (ledger_walker, genesis_block) +{ + nano::system system{}; + auto const node = system.add_node (); + + nano::ledger_walker ledger_walker{ node->ledger }; + + std::size_t walked_blocks_count = 0; + ledger_walker.walk_backward (nano::dev::genesis->hash (), + [&] (auto const & block) { + ++walked_blocks_count; + EXPECT_EQ (block->hash (), nano::dev::genesis->hash ()); + }); + + EXPECT_EQ (walked_blocks_count, 1); + + walked_blocks_count = 0; + ledger_walker.walk (nano::dev::genesis->hash (), + [&] (auto const & block) { + ++walked_blocks_count; + EXPECT_EQ (block->hash (), nano::dev::genesis->hash ()); + }); + + EXPECT_EQ (walked_blocks_count, 1); +} + +namespace nano +{ +TEST (ledger_walker, genesis_account_longer) +{ + nano::system system{}; + nano::node_config node_config (nano::get_available_port (), system.logging); + node_config.enable_voting = true; + node_config.receive_minimum = 1; + + auto const node = system.add_node (node_config); + + nano::ledger_walker ledger_walker{ node->ledger }; + EXPECT_TRUE (ledger_walker.walked_blocks.empty ()); + EXPECT_LE (ledger_walker.walked_blocks.bucket_count (), 1); + EXPECT_TRUE (ledger_walker.blocks_to_walk.empty ()); + + auto const get_number_of_walked_blocks = [&ledger_walker] (auto const & start_block_hash) { + std::size_t walked_blocks_count = 0; + ledger_walker.walk_backward (start_block_hash, + [&] (auto const & block) { + ++walked_blocks_count; + }); + + return walked_blocks_count; + }; + + auto const transaction = node->ledger.store.tx_begin_read (); + nano::account_info genesis_account_info{}; + ASSERT_FALSE (node->ledger.store.account.get (transaction, nano::dev::genesis_key.pub, genesis_account_info)); + EXPECT_EQ (get_number_of_walked_blocks (genesis_account_info.open_block), 1); + EXPECT_EQ (get_number_of_walked_blocks (genesis_account_info.head), 1); + + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + for (auto itr = 1; itr <= 5; ++itr) + { + auto const send = system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 1); + ASSERT_TRUE (send); + EXPECT_EQ (get_number_of_walked_blocks (send->hash ()), 1 + itr * 2 - 1); + ASSERT_TIMELY (3s, 1 + itr * 2 == node->ledger.cache.cemented_count); + ASSERT_FALSE (node->ledger.store.account.get (transaction, nano::dev::genesis_key.pub, genesis_account_info)); + // TODO: check issue with account head + // EXPECT_EQ(get_number_of_walked_blocks (genesis_account_info.head), 1 + itr * 2); + } + + EXPECT_TRUE (ledger_walker.walked_blocks.empty ()); + EXPECT_LE (ledger_walker.walked_blocks.bucket_count (), 1); + EXPECT_TRUE (ledger_walker.blocks_to_walk.empty ()); +} + +} + +TEST (ledger_walker, cross_account) +{ + nano::system system{}; + nano::node_config node_config (nano::get_available_port (), system.logging); + node_config.enable_voting = true; + node_config.receive_minimum = 1; + + auto const node = system.add_node (node_config); + + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + ASSERT_TRUE (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 1)); + ASSERT_TIMELY (3s, 3 == node->ledger.cache.cemented_count); + + nano::keypair key{}; + system.wallet (0)->insert_adhoc (key.prv); + ASSERT_TRUE (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 1)); + ASSERT_TIMELY (3s, 5 == node->ledger.cache.cemented_count); + + auto const transaction = node->ledger.store.tx_begin_read (); + nano::account_info account_info{}; + ASSERT_FALSE (node->ledger.store.account.get (transaction, key.pub, account_info)); + + // TODO: check issue with account head + // auto const first = node->ledger.store.block.get_no_sideband(transaction, account_info.head); + // auto const second = node->ledger.store.block.get_no_sideband(transaction, first->previous()); + // auto const third = node->ledger.store.block.get_no_sideband(transaction, second->previous()); + // auto const fourth = node->ledger.store.block.get_no_sideband(transaction, third->previous()); + // auto const fifth = node->ledger.store.block.get_no_sideband(transaction, fourth->previous()); + // + // auto const expected_blocks_to_walk = { first, second, third, fourth, fifth }; + // auto expected_blocks_to_walk_itr = expected_blocks_to_walk.begin(); + // + // nano::ledger_walker ledger_walker{ node->ledger }; + // ledger_walker.walk_backward (account_info.block_count, [&] (auto const & block) { + // if (expected_blocks_to_walk_itr == expected_blocks_to_walk.end()) + // { + // EXPECT_TRUE(false); + // return false; + // } + // + // EXPECT_EQ((*expected_blocks_to_walk_itr++)->hash(), block->hash()); + // return true; + // }); + // + // EXPECT_EQ(expected_blocks_to_walk_itr, expected_blocks_to_walk.end()); +} + +TEST (ledger_walker, ladder_geometry) +{ + nano::system system{}; + + nano::node_config node_config (nano::get_available_port (), system.logging); + node_config.enable_voting = true; + node_config.receive_minimum = 1; + + auto const node = system.add_node (node_config); + std::array keys{}; + + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + for (auto itr = 0; itr != keys.size (); ++itr) + { + system.wallet (0)->insert_adhoc (keys[itr].prv); + auto const block = system.wallet (0)->send_action (nano::dev::genesis_key.pub, keys[itr].pub, 1000); + ASSERT_TRUE (block); + ASSERT_TIMELY (3s, 1 + (itr + 1) * 2 == node->ledger.cache.cemented_count); + } + + std::vector amounts_to_send (10); + std::iota (amounts_to_send.begin (), amounts_to_send.end (), 1); + + nano::account const * last_destination{}; + for (auto itr = 0; itr != amounts_to_send.size (); ++itr) + { + auto const source_index = itr % keys.size (); + auto const destination_index = (source_index + 1) % keys.size (); + last_destination = &keys[destination_index].pub; + + auto const send = system.wallet (0)->send_action (keys[source_index].pub, keys[destination_index].pub, amounts_to_send[itr]); + ASSERT_TRUE (send); + ASSERT_TIMELY (3s, 1 + keys.size () * 2 + (itr + 1) * 2 == node->ledger.cache.cemented_count); + } + + ASSERT_TRUE (last_destination); + nano::account_info last_destination_info{}; + auto const last_destination_read_error = node->ledger.store.account.get (node->ledger.store.tx_begin_read (), *last_destination, last_destination_info); + ASSERT_FALSE (last_destination_read_error); + + // This is how we expect chains to look like (for 3 accounts and 10 amounts to be sent) + // k1: 1000 SEND 3 SEND 6 SEND 9 SEND + // k2: 1000 1 SEND 4 SEND 7 SEND 10 + // k3: 1000 2 SEND 5 SEND 8 SEND + + std::vector amounts_expected_backwards{ 10, 9, 8, 5, 4, 3, 1000, 1, 1000, 2, 1000, 6, 7 }; + auto amounts_expected_backwards_itr = amounts_expected_backwards.cbegin (); + + nano::ledger_walker ledger_walker{ node->ledger }; + ledger_walker.walk_backward (last_destination_info.head, + [&] (auto const & block) { + if (block->sideband ().details.is_receive) + { + nano::amount previous_balance{}; + if (!block->previous ().is_zero ()) + { + auto const previous_block = node->ledger.store.block.get_no_sideband (node->ledger.store.tx_begin_read (), block->previous ()); + previous_balance = previous_block->balance (); + } + + EXPECT_EQ (*amounts_expected_backwards_itr++, block->balance ().number () - previous_balance.number ()); + } + }); + + EXPECT_EQ (amounts_expected_backwards_itr, amounts_expected_backwards.cend ()); + + auto amounts_expected_itr = amounts_expected_backwards.crbegin (); + + ledger_walker.walk (last_destination_info.head, + [&] (auto const & block) { + if (block->sideband ().details.is_receive) + { + nano::amount previous_balance{}; + if (!block->previous ().is_zero ()) + { + auto const previous_block = node->ledger.store.block.get_no_sideband (node->ledger.store.tx_begin_read (), block->previous ()); + previous_balance = previous_block->balance (); + } + + EXPECT_EQ (*amounts_expected_itr++, block->balance ().number () - previous_balance.number ()); + } + }); + + EXPECT_EQ (amounts_expected_itr, amounts_expected_backwards.crend ()); +} + +#endif // _WIN32 -- TODO: keep this until diskhash builds fine on Windows diff --git a/nano/core_test/message.cpp b/nano/core_test/message.cpp index 35f7ec6c50..9a34906d82 100644 --- a/nano/core_test/message.cpp +++ b/nano/core_test/message.cpp @@ -8,7 +8,7 @@ TEST (message, keepalive_serialization) { - nano::keepalive request1; + nano::keepalive request1{ nano::dev::network_params.network }; std::vector bytes; { nano::vectorstream stream (bytes); @@ -25,7 +25,7 @@ TEST (message, keepalive_serialization) TEST (message, keepalive_deserialize) { - nano::keepalive message1; + nano::keepalive message1{ nano::dev::network_params.network }; message1.peers[0] = nano::endpoint (boost::asio::ip::address_v6::loopback (), 10000); std::vector bytes; { @@ -44,8 +44,7 @@ TEST (message, keepalive_deserialize) TEST (message, publish_serialization) { - nano::network_params params; - nano::publish publish (std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5)); + nano::publish publish{ nano::dev::network_params.network, std::make_shared (0, 1, 2, nano::keypair ().prv, 4, 5) }; ASSERT_EQ (nano::block_type::send, publish.header.block_type ()); std::vector bytes; { @@ -53,11 +52,11 @@ TEST (message, publish_serialization) publish.header.serialize (stream); } ASSERT_EQ (8, bytes.size ()); - ASSERT_EQ (0x52, bytes[0]); + ASSERT_EQ (0x42, bytes[0]); ASSERT_EQ (0x41, bytes[1]); - ASSERT_EQ (params.protocol.protocol_version, bytes[2]); - ASSERT_EQ (params.protocol.protocol_version, bytes[3]); - ASSERT_EQ (params.protocol.protocol_version_min (), bytes[4]); + ASSERT_EQ (nano::dev::network_params.network.protocol_version, bytes[2]); + ASSERT_EQ (nano::dev::network_params.network.protocol_version, bytes[3]); + ASSERT_EQ (nano::dev::network_params.network.protocol_version_min, bytes[4]); ASSERT_EQ (static_cast (nano::message_type::publish), bytes[5]); ASSERT_EQ (0x00, bytes[6]); // extensions ASSERT_EQ (static_cast (nano::block_type::send), bytes[7]); @@ -65,17 +64,17 @@ TEST (message, publish_serialization) auto error (false); nano::message_header header (error, stream); ASSERT_FALSE (error); - ASSERT_EQ (params.protocol.protocol_version_min (), header.version_min ()); - ASSERT_EQ (params.protocol.protocol_version, header.version_using); - ASSERT_EQ (params.protocol.protocol_version, header.version_max); + ASSERT_EQ (nano::dev::network_params.network.protocol_version_min, header.version_min); + ASSERT_EQ (nano::dev::network_params.network.protocol_version, header.version_using); + ASSERT_EQ (nano::dev::network_params.network.protocol_version, header.version_max); ASSERT_EQ (nano::message_type::publish, header.type); } TEST (message, confirm_ack_serialization) { nano::keypair key1; - auto vote (std::make_shared (key1.pub, key1.prv, 0, std::make_shared (0, 1, 2, key1.prv, 4, 5))); - nano::confirm_ack con1 (vote); + auto vote (std::make_shared (key1.pub, key1.prv, 0, 0, std::make_shared (0, 1, 2, key1.prv, 4, 5))); + nano::confirm_ack con1{ nano::dev::network_params.network, vote }; std::vector bytes; { nano::vectorstream stream1 (bytes); @@ -102,8 +101,8 @@ TEST (message, confirm_ack_hash_serialization) hashes.push_back (block.hash ()); } nano::keypair representative1; - auto vote (std::make_shared (representative1.pub, representative1.prv, 0, hashes)); - nano::confirm_ack con1 (vote); + auto vote (std::make_shared (representative1.pub, representative1.prv, 0, 0, hashes)); + nano::confirm_ack con1{ nano::dev::network_params.network, vote }; std::vector bytes; { nano::vectorstream stream1 (bytes); @@ -131,7 +130,7 @@ TEST (message, confirm_req_serialization) nano::keypair key1; nano::keypair key2; auto block (std::make_shared (0, key2.pub, 200, nano::keypair ().prv, 2, 3)); - nano::confirm_req req (block); + nano::confirm_req req{ nano::dev::network_params.network, block }; std::vector bytes; { nano::vectorstream stream (bytes); @@ -151,7 +150,7 @@ TEST (message, confirm_req_hash_serialization) nano::keypair key1; nano::keypair key2; nano::send_block block (1, key2.pub, 200, nano::keypair ().prv, 2, 3); - nano::confirm_req req (block.hash (), block.root ()); + nano::confirm_req req{ nano::dev::network_params.network, block.hash (), block.root () }; std::vector bytes; { nano::vectorstream stream (bytes); @@ -184,7 +183,7 @@ TEST (message, confirm_req_hash_batch_serialization) roots_hashes.push_back (std::make_pair (block.hash (), block.root ())); } roots_hashes.push_back (std::make_pair (open.hash (), open.root ())); - nano::confirm_req req (roots_hashes); + nano::confirm_req req{ nano::dev::network_params.network, roots_hashes }; std::vector bytes; { nano::vectorstream stream (bytes); diff --git a/nano/core_test/message_parser.cpp b/nano/core_test/message_parser.cpp index 20fc2e6c60..5430cc3ec2 100644 --- a/nano/core_test/message_parser.cpp +++ b/nano/core_test/message_parser.cpp @@ -1,4 +1,4 @@ -#include +#include #include #include @@ -67,10 +67,10 @@ TEST (message_parser, exact_confirm_ack_size) nano::network_filter filter (1); nano::block_uniquer block_uniquer; nano::vote_uniquer vote_uniquer (block_uniquer); - nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work); + nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, nano::dev::network_params.network); auto block (std::make_shared (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1)))); - auto vote (std::make_shared (0, nano::keypair ().prv, 0, std::move (block))); - nano::confirm_ack message (vote); + auto vote (std::make_shared (0, nano::keypair ().prv, 0, 0, std::move (block))); + nano::confirm_ack message{ nano::dev::network_params.network, vote }; std::vector bytes; { nano::vectorstream stream (bytes); @@ -101,9 +101,9 @@ TEST (message_parser, exact_confirm_req_size) nano::network_filter filter (1); nano::block_uniquer block_uniquer; nano::vote_uniquer vote_uniquer (block_uniquer); - nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work); + nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, nano::dev::network_params.network); auto block (std::make_shared (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1)))); - nano::confirm_req message (std::move (block)); + nano::confirm_req message{ nano::dev::network_params.network, block }; std::vector bytes; { nano::vectorstream stream (bytes); @@ -134,9 +134,9 @@ TEST (message_parser, exact_confirm_req_hash_size) nano::network_filter filter (1); nano::block_uniquer block_uniquer; nano::vote_uniquer vote_uniquer (block_uniquer); - nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work); + nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, nano::dev::network_params.network); nano::send_block block (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1))); - nano::confirm_req message (block.hash (), block.root ()); + nano::confirm_req message{ nano::dev::network_params.network, block.hash (), block.root () }; std::vector bytes; { nano::vectorstream stream (bytes); @@ -167,9 +167,9 @@ TEST (message_parser, exact_publish_size) nano::network_filter filter (1); nano::block_uniquer block_uniquer; nano::vote_uniquer vote_uniquer (block_uniquer); - nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work); + nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, nano::dev::network_params.network); auto block (std::make_shared (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1)))); - nano::publish message (std::move (block)); + nano::publish message{ nano::dev::network_params.network, block }; std::vector bytes; { nano::vectorstream stream (bytes); @@ -200,8 +200,8 @@ TEST (message_parser, exact_keepalive_size) nano::network_filter filter (1); nano::block_uniquer block_uniquer; nano::vote_uniquer vote_uniquer (block_uniquer); - nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work); - nano::keepalive message; + nano::message_parser parser (filter, block_uniquer, vote_uniquer, visitor, system.work, nano::dev::network_params.network); + nano::keepalive message{ nano::dev::network_params.network }; std::vector bytes; { nano::vectorstream stream (bytes); diff --git a/nano/core_test/network.cpp b/nano/core_test/network.cpp index 304c727e6c..a6940eb74f 100644 --- a/nano/core_test/network.cpp +++ b/nano/core_test/network.cpp @@ -1,6 +1,7 @@ -#include +#include #include #include +#include #include #include @@ -85,7 +86,7 @@ TEST (network, send_node_id_handshake) system.nodes.push_back (node1); auto initial (node0->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in)); auto initial_node1 (node1->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in)); - auto channel (std::make_shared (node0->network.udp_channels, node1->network.endpoint (), node1->network_params.protocol.protocol_version)); + auto channel (std::make_shared (node0->network.udp_channels, node1->network.endpoint (), node1->network_params.network.protocol_version)); node0->network.send_keepalive (channel); ASSERT_EQ (0, node0->network.size ()); ASSERT_EQ (0, node1->network.size ()); @@ -112,7 +113,7 @@ TEST (network, send_node_id_handshake_tcp) auto initial_node1 (node1->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in)); auto initial_keepalive (node0->stats.count (nano::stat::type::message, nano::stat::detail::keepalive, nano::stat::dir::in)); std::weak_ptr node_w (node0); - node0->network.tcp_channels.start_tcp (node1->network.endpoint (), nano::keepalive_tcp_callback (*node1)); + node0->network.tcp_channels.start_tcp (node1->network.endpoint ()); ASSERT_EQ (0, node0->network.size ()); ASSERT_EQ (0, node1->network.size ()); ASSERT_TIMELY (10s, node0->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in) >= initial + 2); @@ -133,25 +134,48 @@ TEST (network, send_node_id_handshake_tcp) TEST (network, last_contacted) { nano::system system (1); + auto node0 = system.nodes[0]; ASSERT_EQ (0, node0->network.size ()); + nano::node_config node1_config (nano::get_available_port (), system.logging); node1_config.tcp_incoming_connections_max = 0; // Prevent ephemeral node1->node0 channel repacement with incoming connection auto node1 (std::make_shared (system.io_ctx, nano::unique_path (), node1_config, system.work)); node1->start (); system.nodes.push_back (node1); + auto channel1 = nano::establish_tcp (system, *node1, node0->network.endpoint ()); ASSERT_NE (nullptr, channel1); ASSERT_TIMELY (3s, node0->network.size () == 1); - auto channel2 = node0->network.tcp_channels.find_node_id (node1->node_id.pub); - ASSERT_NE (nullptr, channel2); - // Make sure last_contact gets updated on receiving a non-handshake message - auto timestamp_before_keepalive = channel2->get_last_packet_received (); + + // channel0 is the other side of channel1, same connection different endpoint + auto channel0 = node0->network.tcp_channels.find_node_id (node1->node_id.pub); + ASSERT_NE (nullptr, channel0); + + { + // check that the endpoints are part of the same connection + std::shared_ptr sock0 = channel0->socket.lock (); + std::shared_ptr sock1 = channel1->socket.lock (); + ASSERT_TRUE (sock0->local_endpoint () == sock1->remote_endpoint ()); + ASSERT_TRUE (sock1->local_endpoint () == sock0->remote_endpoint ()); + } + + // capture the state before and ensure the clock ticks at least once + auto timestamp_before_keepalive = channel0->get_last_packet_received (); auto keepalive_count = node0->stats.count (nano::stat::type::message, nano::stat::detail::keepalive, nano::stat::dir::in); + ASSERT_TIMELY (3s, std::chrono::steady_clock::now () > timestamp_before_keepalive); + + // send 3 keepalives + // we need an extra keepalive to handle the race condition between the timestamp set and the counter increment + // and we need one more keepalive to handle the possibility that there is a keepalive already in flight when we start the crucial part of the test + // it is possible that there could be multiple keepalives in flight but we assume here that there will be no more than one in flight for the purposes of this test + node1->network.send_keepalive (channel1); node1->network.send_keepalive (channel1); - ASSERT_TIMELY (3s, node0->stats.count (nano::stat::type::message, nano::stat::detail::keepalive, nano::stat::dir::in) > keepalive_count); + node1->network.send_keepalive (channel1); + + ASSERT_TIMELY (3s, node0->stats.count (nano::stat::type::message, nano::stat::detail::keepalive, nano::stat::dir::in) >= keepalive_count + 3); ASSERT_EQ (node0->network.size (), 1); - auto timestamp_after_keepalive = channel2->get_last_packet_received (); + auto timestamp_after_keepalive = channel0->get_last_packet_received (); ASSERT_GT (timestamp_after_keepalive, timestamp_before_keepalive); } @@ -166,13 +190,13 @@ TEST (network, multi_keepalive) system.nodes.push_back (node1); ASSERT_EQ (0, node1->network.size ()); ASSERT_EQ (0, node0->network.size ()); - node1->network.tcp_channels.start_tcp (node0->network.endpoint (), nano::keepalive_tcp_callback (*node1)); + node1->network.tcp_channels.start_tcp (node0->network.endpoint ()); ASSERT_TIMELY (10s, node0->network.size () == 1 && node0->stats.count (nano::stat::type::message, nano::stat::detail::keepalive) >= 1); auto node2 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); ASSERT_FALSE (node2->init_error ()); node2->start (); system.nodes.push_back (node2); - node2->network.tcp_channels.start_tcp (node0->network.endpoint (), nano::keepalive_tcp_callback (*node2)); + node2->network.tcp_channels.start_tcp (node0->network.endpoint ()); ASSERT_TIMELY (10s, node1->network.size () == 2 && node0->network.size () == 2 && node2->network.size () == 2 && node0->stats.count (nano::stat::type::message, nano::stat::detail::keepalive) >= 2); } @@ -182,17 +206,16 @@ TEST (network, send_discarded_publish) auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); auto block (std::make_shared (1, 1, 2, nano::keypair ().prv, 4, *system.work.generate (nano::root (1)))); - nano::genesis genesis; { auto transaction (node1.store.tx_begin_read ()); node1.network.flood_block (block); - ASSERT_EQ (genesis.hash (), node1.ledger.latest (transaction, nano::dev_genesis_key.pub)); - ASSERT_EQ (genesis.hash (), node2.latest (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::genesis->hash (), node2.latest (nano::dev::genesis_key.pub)); } ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0); auto transaction (node1.store.tx_begin_read ()); - ASSERT_EQ (genesis.hash (), node1.ledger.latest (transaction, nano::dev_genesis_key.pub)); - ASSERT_EQ (genesis.hash (), node2.latest (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::genesis->hash (), node2.latest (nano::dev::genesis_key.pub)); } TEST (network, send_invalid_publish) @@ -200,18 +223,17 @@ TEST (network, send_invalid_publish) nano::system system (2); auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); - nano::genesis genesis; - auto block (std::make_shared (1, 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::root (1)))); + auto block (std::make_shared (1, 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::root (1)))); { auto transaction (node1.store.tx_begin_read ()); node1.network.flood_block (block); - ASSERT_EQ (genesis.hash (), node1.ledger.latest (transaction, nano::dev_genesis_key.pub)); - ASSERT_EQ (genesis.hash (), node2.latest (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::genesis->hash (), node2.latest (nano::dev::genesis_key.pub)); } ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0); auto transaction (node1.store.tx_begin_read ()); - ASSERT_EQ (genesis.hash (), node1.ledger.latest (transaction, nano::dev_genesis_key.pub)); - ASSERT_EQ (genesis.hash (), node2.latest (nano::dev_genesis_key.pub)); + ASSERT_EQ (nano::dev::genesis->hash (), node1.ledger.latest (transaction, nano::dev::genesis_key.pub)); + ASSERT_EQ (nano::dev::genesis->hash (), node2.latest (nano::dev::genesis_key.pub)); } TEST (network, send_valid_confirm_ack) @@ -230,16 +252,16 @@ TEST (network, send_valid_confirm_ack) auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (1)->insert_adhoc (key2.prv); - nano::block_hash latest1 (node1.latest (nano::dev_genesis_key.pub)); - nano::send_block block2 (latest1, key2.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest1)); - nano::block_hash latest2 (node2.latest (nano::dev_genesis_key.pub)); + nano::block_hash latest1 (node1.latest (nano::dev::genesis_key.pub)); + nano::send_block block2 (latest1, key2.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1)); + nano::block_hash latest2 (node2.latest (nano::dev::genesis_key.pub)); node1.process_active (std::make_shared (block2)); // Keep polling until latest block changes - ASSERT_TIMELY (10s, node2.latest (nano::dev_genesis_key.pub) != latest2); + ASSERT_TIMELY (10s, node2.latest (nano::dev::genesis_key.pub) != latest2); // Make sure the balance has decreased after processing the block. - ASSERT_EQ (50, node2.balance (nano::dev_genesis_key.pub)); + ASSERT_EQ (50, node2.balance (nano::dev::genesis_key.pub)); } } @@ -260,18 +282,18 @@ TEST (network, send_valid_publish) auto & node2 (*system.nodes[1]); node1.bootstrap_initiator.stop (); node2.bootstrap_initiator.stop (); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key2; system.wallet (1)->insert_adhoc (key2.prv); - nano::block_hash latest1 (node1.latest (nano::dev_genesis_key.pub)); - nano::send_block block2 (latest1, key2.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest1)); + nano::block_hash latest1 (node1.latest (nano::dev::genesis_key.pub)); + nano::send_block block2 (latest1, key2.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1)); auto hash2 (block2.hash ()); - nano::block_hash latest2 (node2.latest (nano::dev_genesis_key.pub)); + nano::block_hash latest2 (node2.latest (nano::dev::genesis_key.pub)); node2.process_active (std::make_shared (block2)); ASSERT_TIMELY (10s, node1.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0); ASSERT_NE (hash2, latest2); - ASSERT_TIMELY (10s, node2.latest (nano::dev_genesis_key.pub) != latest2); - ASSERT_EQ (50, node2.balance (nano::dev_genesis_key.pub)); + ASSERT_TIMELY (10s, node2.latest (nano::dev::genesis_key.pub) != latest2); + ASSERT_EQ (50, node2.balance (nano::dev::genesis_key.pub)); } } @@ -282,9 +304,9 @@ TEST (network, send_insufficient_work_udp) node_flags.disable_udp = false; auto & node1 = *system.add_node (node_flags); auto & node2 = *system.add_node (node_flags); - auto block (std::make_shared (0, 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); - nano::publish publish (block); - nano::transport::channel_udp channel (node1.network.udp_channels, node2.network.endpoint (), node1.network_params.protocol.protocol_version); + auto block (std::make_shared (0, 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); + nano::publish publish{ nano::dev::network_params.network, block }; + nano::transport::channel_udp channel (node1.network.udp_channels, node2.network.endpoint (), node1.network_params.network.protocol_version); channel.send (publish, [] (boost::system::error_code const & ec, size_t size) {}); ASSERT_EQ (0, node1.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 0); @@ -297,29 +319,29 @@ TEST (network, send_insufficient_work) auto & node1 = *system.nodes[0]; auto & node2 = *system.nodes[1]; // Block zero work - auto block1 (std::make_shared (0, 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); - nano::publish publish1 (block1); + auto block1 (std::make_shared (0, 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); + nano::publish publish1{ nano::dev::network_params.network, block1 }; auto tcp_channel (node1.network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node2.network.endpoint ()))); tcp_channel->send (publish1, [] (boost::system::error_code const & ec, size_t size) {}); ASSERT_EQ (0, node1.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 0); ASSERT_EQ (1, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); // Legacy block work between epoch_2_recieve & epoch_1 - auto block2 (std::make_shared (block1->hash (), 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1))); - nano::publish publish2 (block2); + auto block2 (std::make_shared (block1->hash (), 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1))); + nano::publish publish2{ nano::dev::network_params.network, block2 }; tcp_channel->send (publish2, [] (boost::system::error_code const & ec, size_t size) {}); ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work) != 1); ASSERT_EQ (2, node2.stats.count (nano::stat::type::error, nano::stat::detail::insufficient_work)); // Legacy block work epoch_1 - auto block3 (std::make_shared (block2->hash (), 1, 20, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (block2->hash (), node1.network_params.network.publish_thresholds.epoch_2))); - nano::publish publish3 (block3); + auto block3 (std::make_shared (block2->hash (), 1, 20, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (block2->hash (), node1.network_params.work.epoch_2))); + nano::publish publish3{ nano::dev::network_params.network, block3 }; tcp_channel->send (publish3, [] (boost::system::error_code const & ec, size_t size) {}); ASSERT_EQ (0, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in)); ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0); ASSERT_EQ (1, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in)); // State block work epoch_2_recieve - auto block4 (std::make_shared (nano::dev_genesis_key.pub, block1->hash (), nano::dev_genesis_key.pub, 20, 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.network.publish_thresholds.epoch_2_receive, node1.network_params.network.publish_thresholds.epoch_1 - 1))); - nano::publish publish4 (block4); + auto block4 (std::make_shared (nano::dev::genesis_key.pub, block1->hash (), nano::dev::genesis_key.pub, 20, 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (block1->hash (), node1.network_params.work.epoch_2_receive, node1.network_params.work.epoch_1 - 1))); + nano::publish publish4{ nano::dev::network_params.network, block4 }; tcp_channel->send (publish4, [] (boost::system::error_code const & ec, size_t size) {}); ASSERT_TIMELY (10s, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in) != 0); ASSERT_EQ (1, node2.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::in)); @@ -330,29 +352,27 @@ TEST (receivable_processor, confirm_insufficient_pos) { nano::system system (1); auto & node1 (*system.nodes[0]); - nano::genesis genesis; - auto block1 (std::make_shared (genesis.hash (), 0, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto block1 (std::make_shared (nano::dev::genesis->hash (), 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*block1); ASSERT_EQ (nano::process_result::progress, node1.process (*block1).code); - node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ()); + node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); nano::keypair key1; - auto vote (std::make_shared (key1.pub, key1.prv, 0, block1)); - nano::confirm_ack con1 (vote); - node1.network.process_message (con1, node1.network.udp_channels.create (node1.network.endpoint ())); + auto vote (std::make_shared (key1.pub, key1.prv, 0, 0, block1)); + nano::confirm_ack con1{ nano::dev::network_params.network, vote }; + node1.network.inbound (con1, node1.network.udp_channels.create (node1.network.endpoint ())); } TEST (receivable_processor, confirm_sufficient_pos) { nano::system system (1); auto & node1 (*system.nodes[0]); - nano::genesis genesis; - auto block1 (std::make_shared (genesis.hash (), 0, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto block1 (std::make_shared (nano::dev::genesis->hash (), 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); node1.work_generate_blocking (*block1); ASSERT_EQ (nano::process_result::progress, node1.process (*block1).code); - node1.scheduler.activate (nano::dev_genesis_key.pub, node1.store.tx_begin_read ()); - auto vote (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, block1)); - nano::confirm_ack con1 (vote); - node1.network.process_message (con1, node1.network.udp_channels.create (node1.network.endpoint ())); + node1.scheduler.activate (nano::dev::genesis_key.pub, node1.store.tx_begin_read ()); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, block1)); + nano::confirm_ack con1{ nano::dev::network_params.network, vote }; + node1.network.inbound (con1, node1.network.udp_channels.create (node1.network.endpoint ())); } TEST (receivable_processor, send_with_receive) @@ -372,26 +392,26 @@ TEST (receivable_processor, send_with_receive) auto & node2 (*system.nodes[1]); auto amount (std::numeric_limits::max ()); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - nano::block_hash latest1 (node1.latest (nano::dev_genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + nano::block_hash latest1 (node1.latest (nano::dev::genesis_key.pub)); system.wallet (1)->insert_adhoc (key2.prv); - auto block1 (std::make_shared (latest1, key2.pub, amount - node1.config.receive_minimum.number (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest1))); - ASSERT_EQ (amount, node1.balance (nano::dev_genesis_key.pub)); + auto block1 (std::make_shared (latest1, key2.pub, amount - node1.config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest1))); + ASSERT_EQ (amount, node1.balance (nano::dev::genesis_key.pub)); ASSERT_EQ (0, node1.balance (key2.pub)); - ASSERT_EQ (amount, node2.balance (nano::dev_genesis_key.pub)); + ASSERT_EQ (amount, node2.balance (nano::dev::genesis_key.pub)); ASSERT_EQ (0, node2.balance (key2.pub)); node1.process_active (block1); node1.block_processor.flush (); node2.process_active (block1); node2.block_processor.flush (); - ASSERT_EQ (amount - node1.config.receive_minimum.number (), node1.balance (nano::dev_genesis_key.pub)); + ASSERT_EQ (amount - node1.config.receive_minimum.number (), node1.balance (nano::dev::genesis_key.pub)); ASSERT_EQ (0, node1.balance (key2.pub)); - ASSERT_EQ (amount - node1.config.receive_minimum.number (), node2.balance (nano::dev_genesis_key.pub)); + ASSERT_EQ (amount - node1.config.receive_minimum.number (), node2.balance (nano::dev::genesis_key.pub)); ASSERT_EQ (0, node2.balance (key2.pub)); ASSERT_TIMELY (10s, node1.balance (key2.pub) == node1.config.receive_minimum.number () && node2.balance (key2.pub) == node1.config.receive_minimum.number ()); - ASSERT_EQ (amount - node1.config.receive_minimum.number (), node1.balance (nano::dev_genesis_key.pub)); + ASSERT_EQ (amount - node1.config.receive_minimum.number (), node1.balance (nano::dev::genesis_key.pub)); ASSERT_EQ (node1.config.receive_minimum.number (), node1.balance (key2.pub)); - ASSERT_EQ (amount - node1.config.receive_minimum.number (), node2.balance (nano::dev_genesis_key.pub)); + ASSERT_EQ (amount - node1.config.receive_minimum.number (), node2.balance (nano::dev::genesis_key.pub)); ASSERT_EQ (node1.config.receive_minimum.number (), node2.balance (key2.pub)); } } @@ -399,14 +419,14 @@ TEST (receivable_processor, send_with_receive) TEST (network, receive_weight_change) { nano::system system (2); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key2; system.wallet (1)->insert_adhoc (key2.prv); { auto transaction (system.nodes[1]->wallets.tx_begin_write ()); system.wallet (1)->store.representative_set (transaction, key2.pub); } - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); ASSERT_TIMELY (10s, std::all_of (system.nodes.begin (), system.nodes.end (), [&] (std::shared_ptr const & node_a) { return node_a->weight (key2.pub) == system.nodes[0]->config.receive_minimum.number (); })); } @@ -761,10 +781,10 @@ TEST (message_buffer_manager, stats) TEST (tcp_listener, tcp_node_id_handshake) { nano::system system (1); - auto socket (std::make_shared (*system.nodes[0])); + auto socket (std::make_shared (*system.nodes[0])); auto bootstrap_endpoint (system.nodes[0]->bootstrap.endpoint ()); auto cookie (system.nodes[0]->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (bootstrap_endpoint))); - nano::node_id_handshake node_id_handshake (cookie, boost::none); + nano::node_id_handshake node_id_handshake{ nano::dev::network_params.network, cookie, boost::none }; auto input (node_id_handshake.to_shared_const_buffer ()); std::atomic write_done (false); socket->async_connect (bootstrap_endpoint, [&input, socket, &write_done] (boost::system::error_code const & ec) { @@ -778,8 +798,8 @@ TEST (tcp_listener, tcp_node_id_handshake) ASSERT_TIMELY (5s, write_done); - boost::optional> response_zero (std::make_pair (nano::account (0), nano::signature (0))); - nano::node_id_handshake node_id_handshake_response (boost::none, response_zero); + boost::optional> response_zero (std::make_pair (nano::account{}, nano::signature (0))); + nano::node_id_handshake node_id_handshake_response{ nano::dev::network_params.network, boost::none, response_zero }; auto output (node_id_handshake_response.to_bytes ()); std::atomic done (false); socket->async_read (output, output->size (), [&output, &done] (boost::system::error_code const & ec, size_t size_a) { @@ -794,7 +814,7 @@ TEST (tcp_listener, tcp_listener_timeout_empty) { nano::system system (1); auto node0 (system.nodes[0]); - auto socket (std::make_shared (*node0)); + auto socket (std::make_shared (*node0)); std::atomic connected (false); socket->async_connect (node0->bootstrap.endpoint (), [&connected] (boost::system::error_code const & ec) { ASSERT_FALSE (ec); @@ -817,15 +837,14 @@ TEST (tcp_listener, tcp_listener_timeout_node_id_handshake) { nano::system system (1); auto node0 (system.nodes[0]); - auto socket (std::make_shared (*node0)); + auto socket (std::make_shared (*node0)); auto cookie (node0->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (node0->bootstrap.endpoint ()))); - nano::node_id_handshake node_id_handshake (cookie, boost::none); - auto input (node_id_handshake.to_shared_const_buffer ()); - socket->async_connect (node0->bootstrap.endpoint (), [&input, socket] (boost::system::error_code const & ec) { + nano::node_id_handshake node_id_handshake{ nano::dev::network_params.network, cookie, boost::none }; + auto channel = std::make_shared (*node0, socket); + socket->async_connect (node0->bootstrap.endpoint (), [&node_id_handshake, channel] (boost::system::error_code const & ec) { ASSERT_FALSE (ec); - socket->async_write (input, [&input] (boost::system::error_code const & ec, size_t size_a) { + channel->send (node_id_handshake, [] (boost::system::error_code const & ec, size_t size_a) { ASSERT_FALSE (ec); - ASSERT_EQ (input.size (), size_a); }); }); ASSERT_TIMELY (5s, node0->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake) != 0); @@ -860,14 +879,14 @@ TEST (network, replace_port) node1->start (); system.nodes.push_back (node1); auto wrong_endpoint = nano::endpoint (node1->network.endpoint ().address (), nano::get_available_port ()); - auto channel0 (node0->network.udp_channels.insert (wrong_endpoint, node1->network_params.protocol.protocol_version)); + auto channel0 (node0->network.udp_channels.insert (wrong_endpoint, node1->network_params.network.protocol_version)); ASSERT_NE (nullptr, channel0); node0->network.udp_channels.modify (channel0, [&node1] (std::shared_ptr const & channel_a) { channel_a->set_node_id (node1->node_id.pub); }); auto peers_list (node0->network.list (std::numeric_limits::max ())); ASSERT_EQ (peers_list[0]->get_node_id (), node1->node_id.pub); - auto channel1 (std::make_shared (node0->network.udp_channels, node1->network.endpoint (), node1->network_params.protocol.protocol_version)); + auto channel1 (std::make_shared (node0->network.udp_channels, node1->network.endpoint (), node1->network_params.network.protocol_version)); ASSERT_EQ (node0->network.udp_channels.size (), 1); node0->network.send_keepalive (channel1); // On handshake, the channel is replaced @@ -876,12 +895,12 @@ TEST (network, replace_port) TEST (network, peer_max_tcp_attempts) { - nano::system system (1); - auto node (system.nodes[0]); // Add nodes that can accept TCP connection, but not node ID handshake nano::node_flags node_flags; - node_flags.disable_tcp_realtime = true; - for (auto i (0); i < node->network_params.node.max_peers_per_ip; ++i) + node_flags.disable_connection_cleanup = true; + nano::system system; + auto node = system.add_node (node_flags); + for (auto i (0); i < node->network_params.network.max_peers_per_ip; ++i) { auto node2 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work, node_flags)); node2->start (); @@ -900,18 +919,21 @@ namespace transport { TEST (network, peer_max_tcp_attempts_subnetwork) { - nano::system system (1); + nano::node_flags node_flags; + node_flags.disable_max_peers_per_ip = true; + nano::system system; + system.add_node (node_flags); auto node (system.nodes[0]); - for (auto i (0); i < node->network_params.node.max_peers_per_subnetwork; ++i) + for (auto i (0); i < node->network_params.network.max_peers_per_subnetwork; ++i) { auto address (boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (0x7f000001 + i))); // 127.0.0.1 hex nano::endpoint endpoint (address, nano::get_available_port ()); ASSERT_FALSE (node->network.tcp_channels.reachout (endpoint)); } ASSERT_EQ (0, node->network.size ()); - ASSERT_EQ (0, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_max_per_ip, nano::stat::dir::out)); + ASSERT_EQ (0, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_max_per_subnetwork, nano::stat::dir::out)); ASSERT_TRUE (node->network.tcp_channels.reachout (nano::endpoint (boost::asio::ip::make_address_v6 ("::ffff:127.0.0.1"), nano::get_available_port ()))); - ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_max_per_ip, nano::stat::dir::out)); + ASSERT_EQ (1, node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_max_per_subnetwork, nano::stat::dir::out)); } } } @@ -923,9 +945,8 @@ TEST (network, duplicate_detection) node_flags.disable_udp = false; auto & node0 (*system.add_node (node_flags)); auto & node1 (*system.add_node (node_flags)); - auto udp_channel (std::make_shared (node0.network.udp_channels, node1.network.endpoint (), node1.network_params.protocol.protocol_version)); - nano::genesis genesis; - nano::publish publish (genesis.open); + auto udp_channel (std::make_shared (node0.network.udp_channels, node1.network.endpoint (), node1.network_params.network.protocol_version)); + nano::publish publish{ nano::dev::network_params.network, nano::dev::genesis }; // Publish duplicate detection through UDP ASSERT_EQ (0, node1.stats.count (nano::stat::type::filter, nano::stat::detail::duplicate_publish)); @@ -947,8 +968,7 @@ TEST (network, duplicate_revert_publish) node_flags.block_processor_full_size = 0; auto & node (*system.add_node (node_flags)); ASSERT_TRUE (node.block_processor.full ()); - nano::genesis genesis; - nano::publish publish (genesis.open); + nano::publish publish{ nano::dev::network_params.network, nano::dev::genesis }; std::vector bytes; { nano::vectorstream stream (bytes); @@ -966,10 +986,10 @@ TEST (network, duplicate_revert_publish) auto channel = nano::establish_tcp (system, *other_node, node.network.endpoint ()); ASSERT_NE (nullptr, channel); ASSERT_EQ (0, publish.digest); - node.network.process_message (publish, channel); + node.network.inbound (publish, channel); ASSERT_TRUE (node.network.publish_filter.apply (bytes.data (), bytes.size ())); publish.digest = digest; - node.network.process_message (publish, channel); + node.network.inbound (publish, channel); ASSERT_FALSE (node.network.publish_filter.apply (bytes.data (), bytes.size ())); } @@ -977,8 +997,7 @@ TEST (network, duplicate_revert_publish) TEST (network, bandwidth_limiter) { nano::system system; - nano::genesis genesis; - nano::publish message (genesis.open); + nano::publish message{ nano::dev::network_params.network, nano::dev::genesis }; auto message_size = message.to_bytes ()->size (); auto message_limit = 4; // must be multiple of the number of channels nano::node_config node_config (nano::get_available_port (), system.logging); @@ -1191,7 +1210,7 @@ TEST (network, cleanup_purge) node1.network.cleanup (test_start); ASSERT_EQ (0, node1.network.size ()); - node1.network.udp_channels.insert (node2->network.endpoint (), node1.network_params.protocol.protocol_version); + node1.network.udp_channels.insert (node2->network.endpoint (), node1.network_params.network.protocol_version); ASSERT_EQ (1, node1.network.size ()); node1.network.cleanup (test_start); ASSERT_EQ (1, node1.network.size ()); @@ -1200,12 +1219,7 @@ TEST (network, cleanup_purge) ASSERT_EQ (0, node1.network.size ()); std::weak_ptr node_w = node1.shared (); - node1.network.tcp_channels.start_tcp (node2->network.endpoint (), [node_w] (std::shared_ptr const & channel_a) { - if (auto node_l = node_w.lock ()) - { - node_l->network.send_keepalive (channel_a); - } - }); + node1.network.tcp_channels.start_tcp (node2->network.endpoint ()); ASSERT_TIMELY (3s, node1.network.size () == 1); node1.network.cleanup (test_start); @@ -1224,7 +1238,7 @@ TEST (network, loopback_channel) ASSERT_EQ (channel1.get_type (), nano::transport::transport_type::loopback); ASSERT_EQ (channel1.get_endpoint (), node1.network.endpoint ()); ASSERT_EQ (channel1.get_tcp_endpoint (), nano::transport::map_endpoint_to_tcp (node1.network.endpoint ())); - ASSERT_EQ (channel1.get_network_version (), node1.network_params.protocol.protocol_version); + ASSERT_EQ (channel1.get_network_version (), node1.network_params.network.protocol_version); ASSERT_EQ (channel1.get_node_id (), node1.node_id.pub); ASSERT_EQ (channel1.get_node_id_optional ().value_or (0), node1.node_id.pub); nano::transport::channel_loopback channel2 (node2); @@ -1233,3 +1247,25 @@ TEST (network, loopback_channel) ++node1.network.port; ASSERT_NE (channel1.get_endpoint (), node1.network.endpoint ()); } + +// Ensure the network filters messages with the incorrect magic number +TEST (network, filter) +{ + nano::system system{ 1 }; + auto & node1 = *system.nodes[0]; + nano::keepalive keepalive{ nano::dev::network_params.network }; + const_cast (keepalive.header.network) = nano::networks::nano_dev_network; + node1.network.inbound (keepalive, std::make_shared (node1)); + ASSERT_EQ (0, node1.stats.count (nano::stat::type::message, nano::stat::detail::invalid_network)); + const_cast (keepalive.header.network) = nano::networks::invalid; + node1.network.inbound (keepalive, std::make_shared (node1)); + ASSERT_EQ (1, node1.stats.count (nano::stat::type::message, nano::stat::detail::invalid_network)); +} + +TEST (network, fill_keepalive_self) +{ + nano::system system{ 2 }; + std::array target; + system.nodes[0]->network.fill_keepalive_self (target); + ASSERT_TRUE (target[2].port () == system.nodes[1]->network.port); +} diff --git a/nano/core_test/network_filter.cpp b/nano/core_test/network_filter.cpp index 2f6dfb7f43..ece5c4649b 100644 --- a/nano/core_test/network_filter.cpp +++ b/nano/core_test/network_filter.cpp @@ -8,10 +8,9 @@ TEST (network_filter, unit) { - nano::genesis genesis; nano::network_filter filter (1); auto one_block = [&filter] (std::shared_ptr const & block_a, bool expect_duplicate_a) { - nano::publish message (block_a); + nano::publish message{ nano::dev::network_params.network, block_a }; auto bytes (message.to_bytes ()); nano::bufferstream stream (bytes->data (), bytes->size ()); @@ -32,19 +31,19 @@ TEST (network_filter, unit) ASSERT_NE (nullptr, block); ASSERT_EQ (*block, *block_a); }; - one_block (genesis.open, false); + one_block (nano::dev::genesis, false); for (int i = 0; i < 10; ++i) { - one_block (genesis.open, true); + one_block (nano::dev::genesis, true); } nano::state_block_builder builder; auto new_block = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.open->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 10 * nano::RAW_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 10 * nano::RAW_ratio) .link (nano::public_key ()) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) .build_shared (); @@ -55,30 +54,29 @@ TEST (network_filter, unit) } for (int i = 0; i < 100; ++i) { - one_block (genesis.open, false); + one_block (nano::dev::genesis, false); one_block (new_block, false); } } TEST (network_filter, many) { - nano::genesis genesis; nano::network_filter filter (4); nano::keypair key1; for (int i = 0; i < 100; ++i) { nano::state_block_builder builder; auto block = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.open->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - i * 10 * nano::RAW_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - i * 10 * nano::RAW_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) .build_shared (); - nano::publish message (block); + nano::publish message{ nano::dev::network_params.network, block }; auto bytes (message.to_bytes ()); nano::bufferstream stream (bytes->data (), bytes->size ()); diff --git a/nano/core_test/node.cpp b/nano/core_test/node.cpp index f9024c04f2..d5a8225d62 100644 --- a/nano/core_test/node.cpp +++ b/nano/core_test/node.cpp @@ -1,8 +1,8 @@ #include #include -#include #include #include +#include #include #include @@ -20,6 +20,17 @@ namespace void add_required_children_node_config_tree (nano::jsonconfig & tree); } +TEST (node, null_account) +{ + auto const & null_account = nano::account::null (); + ASSERT_TRUE (null_account == nullptr); + ASSERT_FALSE (null_account != nullptr); + + nano::account default_account{}; + ASSERT_FALSE (default_account == nullptr); + ASSERT_TRUE (default_account != nullptr); +} + TEST (node, stop) { nano::system system (1); @@ -36,21 +47,21 @@ TEST (node, work_generate) nano::block_hash root{ 1 }; nano::work_version version{ nano::work_version::work_1 }; { - auto difficulty = nano::difficulty::from_multiplier (1.5, node.network_params.network.publish_thresholds.base); + auto difficulty = nano::difficulty::from_multiplier (1.5, node.network_params.work.base); auto work = node.work_generate_blocking (version, root, difficulty); ASSERT_TRUE (work.is_initialized ()); - ASSERT_TRUE (nano::work_difficulty (version, root, *work) >= difficulty); + ASSERT_TRUE (nano::dev::network_params.work.difficulty (version, root, *work) >= difficulty); } { - auto difficulty = nano::difficulty::from_multiplier (0.5, node.network_params.network.publish_thresholds.base); + auto difficulty = nano::difficulty::from_multiplier (0.5, node.network_params.work.base); boost::optional work; do { work = node.work_generate_blocking (version, root, difficulty); - } while (nano::work_difficulty (version, root, *work) >= node.network_params.network.publish_thresholds.base); + } while (nano::dev::network_params.work.difficulty (version, root, *work) >= node.network_params.work.base); ASSERT_TRUE (work.is_initialized ()); - ASSERT_TRUE (nano::work_difficulty (version, root, *work) >= difficulty); - ASSERT_FALSE (nano::work_difficulty (version, root, *work) >= node.network_params.network.publish_thresholds.base); + ASSERT_TRUE (nano::dev::network_params.work.difficulty (version, root, *work) >= difficulty); + ASSERT_FALSE (nano::dev::network_params.work.difficulty (version, root, *work) >= node.network_params.work.base); } } @@ -60,8 +71,8 @@ TEST (node, block_store_path_failure) auto path (nano::unique_path ()); nano::logging logging; logging.init (path); - nano::work_pool work (std::numeric_limits::max ()); - auto node (std::make_shared (*service, nano::get_available_port (), path, logging, work)); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; + auto node (std::make_shared (*service, nano::get_available_port (), path, logging, pool)); ASSERT_TRUE (node->wallets.items.empty ()); node->stop (); } @@ -73,7 +84,7 @@ TEST (node_DeathTest, readonly_block_store_not_exist) #endif { // This is a read-only node with no ledger file - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { nano::inactive_node node (nano::unique_path (), nano::inactive_node_flag_defaults ()); ASSERT_TRUE (node.node->init_error ()); @@ -91,9 +102,9 @@ TEST (node, password_fanout) nano::node_config config; config.peering_port = nano::get_available_port (); config.logging.init (path); - nano::work_pool work (std::numeric_limits::max ()); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; config.password_fanout = 10; - nano::node node (io_ctx, path, config, work); + nano::node node (io_ctx, path, config, pool); auto wallet (node.wallets.create (100)); ASSERT_EQ (10, wallet->store.password.values.size ()); node.stop (); @@ -102,18 +113,18 @@ TEST (node, password_fanout) TEST (node, balance) { nano::system system (1); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto transaction (system.nodes[0]->store.tx_begin_write ()); - ASSERT_EQ (std::numeric_limits::max (), system.nodes[0]->ledger.account_balance (transaction, nano::dev_genesis_key.pub)); + ASSERT_EQ (std::numeric_limits::max (), system.nodes[0]->ledger.account_balance (transaction, nano::dev::genesis_key.pub)); } TEST (node, representative) { nano::system system (1); - auto block1 (system.nodes[0]->rep_block (nano::dev_genesis_key.pub)); + auto block1 (system.nodes[0]->rep_block (nano::dev::genesis_key.pub)); { auto transaction (system.nodes[0]->store.tx_begin_read ()); - ASSERT_TRUE (system.nodes[0]->ledger.store.block_exists (transaction, block1)); + ASSERT_TRUE (system.nodes[0]->ledger.store.block.exists (transaction, block1)); } nano::keypair key; ASSERT_TRUE (system.nodes[0]->rep_block (key.pub).is_zero ()); @@ -123,30 +134,30 @@ TEST (node, send_unkeyed) { nano::system system (1); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->store.password.value_set (nano::keypair ().prv); - ASSERT_EQ (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_EQ (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); } TEST (node, send_self) { nano::system system (1); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key2.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); ASSERT_TIMELY (10s, !system.nodes[0]->balance (key2.pub).is_zero ()); - ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (nano::dev_genesis_key.pub)); + ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (nano::dev::genesis_key.pub)); } TEST (node, send_single) { nano::system system (2); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (1)->insert_adhoc (key2.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); - ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (nano::dev_genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (nano::dev::genesis_key.pub)); ASSERT_TRUE (system.nodes[0]->balance (key2.pub).is_zero ()); ASSERT_TIMELY (10s, !system.nodes[0]->balance (key2.pub).is_zero ()); } @@ -155,10 +166,10 @@ TEST (node, send_single_observing_peer) { nano::system system (3); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (1)->insert_adhoc (key2.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); - ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (nano::dev_genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (nano::dev::genesis_key.pub)); ASSERT_TRUE (system.nodes[0]->balance (key2.pub).is_zero ()); ASSERT_TIMELY (10s, std::all_of (system.nodes.begin (), system.nodes.end (), [&] (std::shared_ptr const & node_a) { return !node_a->balance (key2.pub).is_zero (); })); } @@ -167,17 +178,16 @@ TEST (node, send_single_many_peers) { nano::system system (10); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (1)->insert_adhoc (key2.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); - ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (nano::dev_genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, system.nodes[0]->config.receive_minimum.number ())); + ASSERT_EQ (std::numeric_limits::max () - system.nodes[0]->config.receive_minimum.number (), system.nodes[0]->balance (nano::dev::genesis_key.pub)); ASSERT_TRUE (system.nodes[0]->balance (key2.pub).is_zero ()); ASSERT_TIMELY (3.5min, std::all_of (system.nodes.begin (), system.nodes.end (), [&] (std::shared_ptr const & node_a) { return !node_a->balance (key2.pub).is_zero (); })); system.stop (); for (auto node : system.nodes) { ASSERT_TRUE (node->stopped); - ASSERT_TRUE (node->network.tcp_channels.node_id_handhake_sockets_empty ()); } } @@ -186,33 +196,32 @@ TEST (node, send_out_of_order) nano::system system (2); auto & node1 (*system.nodes[0]); nano::keypair key2; - nano::genesis genesis; nano::send_block_builder builder; auto send1 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key2.pub) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number ()) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto send2 = builder.make_block () .previous (send1->hash ()) .destination (key2.pub) .balance (std::numeric_limits::max () - 2 * node1.config.receive_minimum.number ()) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); auto send3 = builder.make_block () .previous (send2->hash ()) .destination (key2.pub) .balance (std::numeric_limits::max () - 3 * node1.config.receive_minimum.number ()) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send2->hash ())) .build_shared (); node1.process_active (send3); node1.process_active (send2); node1.process_active (send1); - ASSERT_TIMELY (10s, std::all_of (system.nodes.begin (), system.nodes.end (), [&] (std::shared_ptr const & node_a) { return node_a->balance (nano::dev_genesis_key.pub) == nano::genesis_amount - node1.config.receive_minimum.number () * 3; })); + ASSERT_TIMELY (10s, std::all_of (system.nodes.begin (), system.nodes.end (), [&] (std::shared_ptr const & node_a) { return node_a->balance (nano::dev::genesis_key.pub) == nano::dev::constants.genesis_amount - node1.config.receive_minimum.number () * 3; })); } TEST (node, quick_confirm) @@ -220,20 +229,20 @@ TEST (node, quick_confirm) nano::system system (1); auto & node1 (*system.nodes[0]); nano::keypair key; - nano::block_hash previous (node1.latest (nano::dev_genesis_key.pub)); - auto genesis_start_balance (node1.balance (nano::dev_genesis_key.pub)); + nano::block_hash previous (node1.latest (nano::dev::genesis_key.pub)); + auto genesis_start_balance (node1.balance (nano::dev::genesis_key.pub)); system.wallet (0)->insert_adhoc (key.prv); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto send = nano::send_block_builder () .previous (previous) .destination (key.pub) .balance (node1.online_reps.delta () + 1) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) .build_shared (); node1.process_active (send); ASSERT_TIMELY (10s, !node1.balance (key.pub).is_zero ()); - ASSERT_EQ (node1.balance (nano::dev_genesis_key.pub), node1.online_reps.delta () + 1); + ASSERT_EQ (node1.balance (nano::dev::genesis_key.pub), node1.online_reps.delta () + 1); ASSERT_EQ (node1.balance (key.pub), genesis_start_balance - (node1.online_reps.delta () + 1)); } @@ -242,13 +251,13 @@ TEST (node, node_receive_quorum) nano::system system (1); auto & node1 = *system.nodes[0]; nano::keypair key; - nano::block_hash previous (node1.latest (nano::dev_genesis_key.pub)); + nano::block_hash previous (node1.latest (nano::dev::genesis_key.pub)); system.wallet (0)->insert_adhoc (key.prv); auto send = nano::send_block_builder () .previous (previous) .destination (key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) .build_shared (); node1.process_active (send); @@ -262,9 +271,9 @@ TEST (node, node_receive_quorum) nano::system system2; system2.add_node (); - system2.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system2.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_TRUE (node1.balance (key.pub).is_zero ()); - node1.network.tcp_channels.start_tcp (system2.nodes[0]->network.endpoint (), nano::keepalive_tcp_callback (node1)); + node1.network.tcp_channels.start_tcp (system2.nodes[0]->network.endpoint ()); while (node1.balance (key.pub).is_zero ()) { ASSERT_NO_ERROR (system.poll ()); @@ -282,9 +291,9 @@ TEST (node, auto_bootstrap) node_flags.disable_lazy_bootstrap = true; auto node0 = system.add_node (config, node_flags); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key2.prv); - auto send1 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node0->config.receive_minimum.number ())); + auto send1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node0->config.receive_minimum.number ())); ASSERT_NE (nullptr, send1); ASSERT_TIMELY (10s, node0->balance (key2.pub) == node0->config.receive_minimum.number ()); auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work, node_flags)); @@ -314,11 +323,11 @@ TEST (node, auto_bootstrap_reverse) node_flags.disable_lazy_bootstrap = true; auto node0 = system.add_node (config, node_flags); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key2.prv); auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work, node_flags)); ASSERT_FALSE (node1->init_error ()); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node0->config.receive_minimum.number ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node0->config.receive_minimum.number ())); node1->start (); system.nodes.push_back (node1); ASSERT_NE (nullptr, nano::establish_tcp (system, *node0, node1->network.endpoint ())); @@ -362,8 +371,8 @@ TEST (node, receive_gap) .work (0) .build_shared (); node1.work_generate_blocking (*block); - nano::publish message (block); - node1.network.process_message (message, node1.network.udp_channels.create (node1.network.endpoint ())); + nano::publish message{ nano::dev::network_params.network, block }; + node1.network.inbound (message, node1.network.udp_channels.create (node1.network.endpoint ())); node1.block_processor.flush (); ASSERT_EQ (1, node1.gap_cache.size ()); } @@ -383,8 +392,8 @@ TEST (node, search_pending) nano::system system (1); auto node (system.nodes[0]); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); system.wallet (0)->insert_adhoc (key2.prv); ASSERT_FALSE (system.wallet (0)->search_pending (system.wallet (0)->wallets.tx_begin_read ())); ASSERT_TIMELY (10s, !node->balance (key2.pub).is_zero ()); @@ -395,9 +404,9 @@ TEST (node, search_pending_same) nano::system system (1); auto node (system.nodes[0]); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); system.wallet (0)->insert_adhoc (key2.prv); ASSERT_FALSE (system.wallet (0)->search_pending (system.wallet (0)->wallets.tx_begin_read ())); ASSERT_TIMELY (10s, node->balance (key2.pub) == 2 * node->config.receive_minimum.number ()); @@ -409,11 +418,11 @@ TEST (node, search_pending_multiple) auto node (system.nodes[0]); nano::keypair key2; nano::keypair key3; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key3.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key3.pub, node->config.receive_minimum.number ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key3.pub, node->config.receive_minimum.number ())); ASSERT_TIMELY (10s, !node->balance (key3.pub).is_zero ()); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); ASSERT_NE (nullptr, system.wallet (0)->send_action (key3.pub, key2.pub, node->config.receive_minimum.number ())); system.wallet (0)->insert_adhoc (key2.prv); ASSERT_FALSE (system.wallet (0)->search_pending (system.wallet (0)->wallets.tx_begin_read ())); @@ -427,10 +436,10 @@ TEST (node, search_pending_confirmed) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto send1 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto send1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); ASSERT_NE (nullptr, send1); - auto send2 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); + auto send2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); ASSERT_NE (nullptr, send2); ASSERT_TIMELY (10s, node->active.empty ()); bool confirmed (false); @@ -443,7 +452,7 @@ TEST (node, search_pending_confirmed) } { auto transaction (node->wallets.tx_begin_write ()); - system.wallet (0)->store.erase (transaction, nano::dev_genesis_key.pub); + system.wallet (0)->store.erase (transaction, nano::dev::genesis_key.pub); } system.wallet (0)->insert_adhoc (key2.prv); ASSERT_FALSE (system.wallet (0)->search_pending (system.wallet (0)->wallets.tx_begin_read ())); @@ -469,17 +478,17 @@ TEST (node, search_pending_pruned) config.enable_voting = false; // Remove after allowing pruned voting auto node2 = system.add_node (config, node_flags); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto send1 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node2->config.receive_minimum.number ())); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto send1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node2->config.receive_minimum.number ())); ASSERT_NE (nullptr, send1); - auto send2 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node2->config.receive_minimum.number ())); + auto send2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node2->config.receive_minimum.number ())); ASSERT_NE (nullptr, send2); // Confirmation ASSERT_TIMELY (10s, node1->active.empty () && node2->active.empty ()); ASSERT_TIMELY (5s, node1->ledger.block_confirmed (node1->store.tx_begin_read (), send2->hash ())); ASSERT_TIMELY (5s, node2->ledger.cache.cemented_count == 3); - system.wallet (0)->store.erase (node1->wallets.tx_begin_write (), nano::dev_genesis_key.pub); + system.wallet (0)->store.erase (node1->wallets.tx_begin_write (), nano::dev::genesis_key.pub); // Pruning { @@ -492,13 +501,6 @@ TEST (node, search_pending_pruned) // Receive pruned block system.wallet (1)->insert_adhoc (key2.prv); ASSERT_FALSE (system.wallet (1)->search_pending (system.wallet (1)->wallets.tx_begin_read ())); - { - nano::lock_guard guard (node2->active.mutex); - auto existing1 (node2->active.blocks.find (send1->hash ())); - ASSERT_EQ (node2->active.blocks.end (), existing1); - auto existing2 (node2->active.blocks.find (send2->hash ())); - ASSERT_EQ (node2->active.blocks.end (), existing2); - } ASSERT_TIMELY (10s, node2->balance (key2.pub) == 2 * node2->config.receive_minimum.number ()); } @@ -507,14 +509,14 @@ TEST (node, unlock_search) nano::system system (1); auto node (system.nodes[0]); nano::keypair key2; - nano::uint128_t balance (node->balance (nano::dev_genesis_key.pub)); + nano::uint128_t balance (node->balance (nano::dev::genesis_key.pub)); { auto transaction (system.wallet (0)->wallets.tx_begin_write ()); system.wallet (0)->store.rekey (transaction, ""); } - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); - ASSERT_TIMELY (10s, node->balance (nano::dev_genesis_key.pub) != balance); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node->config.receive_minimum.number ())); + ASSERT_TIMELY (10s, node->balance (nano::dev::genesis_key.pub) != balance); ASSERT_TIMELY (10s, node->active.empty ()); system.wallet (0)->insert_adhoc (key2.prv); { @@ -537,12 +539,12 @@ TEST (node, connect_after_junk) auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work, node_flags)); std::vector junk_buffer; junk_buffer.push_back (0); - auto channel1 (std::make_shared (node1->network.udp_channels, node0->network.endpoint (), node1->network_params.protocol.protocol_version)); + auto channel1 (std::make_shared (node1->network.udp_channels, node0->network.endpoint (), node1->network_params.network.protocol_version)); channel1->send_buffer (nano::shared_const_buffer (std::move (junk_buffer)), [] (boost::system::error_code const &, size_t) {}); ASSERT_TIMELY (10s, node0->stats.count (nano::stat::type::error) != 0); node1->start (); system.nodes.push_back (node1); - auto channel2 (std::make_shared (node1->network.udp_channels, node0->network.endpoint (), node1->network_params.protocol.protocol_version)); + auto channel2 (std::make_shared (node1->network.udp_channels, node0->network.endpoint (), node1->network_params.network.protocol_version)); node1->network.send_keepalive (channel2); ASSERT_TIMELY (10s, !node1->network.empty ()); node1->stop (); @@ -570,7 +572,7 @@ TEST (node, price) TEST (node, confirm_locked) { nano::system system (1); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto transaction (system.wallet (0)->wallets.tx_begin_read ()); system.wallet (0)->enter_password (transaction, "1"); auto block = nano::send_block_builder () @@ -597,7 +599,6 @@ TEST (node_config, serialization) config1.callback_address = "dev"; config1.callback_port = 10; config1.callback_target = "dev"; - config1.deprecated_lmdb_max_dbs = 256; nano::jsonconfig tree; config1.serialize_json (tree); nano::logging logging2; @@ -613,7 +614,6 @@ TEST (node_config, serialization) ASSERT_NE (config2.callback_address, config1.callback_address); ASSERT_NE (config2.callback_port, config1.callback_port); ASSERT_NE (config2.callback_target, config1.callback_target); - ASSERT_NE (config2.deprecated_lmdb_max_dbs, config1.deprecated_lmdb_max_dbs); ASSERT_FALSE (tree.get_optional ("epoch_block_link")); ASSERT_FALSE (tree.get_optional ("epoch_block_signer")); @@ -630,7 +630,6 @@ TEST (node_config, serialization) ASSERT_EQ (config2.callback_address, config1.callback_address); ASSERT_EQ (config2.callback_port, config1.callback_port); ASSERT_EQ (config2.callback_target, config1.callback_target); - ASSERT_EQ (config2.deprecated_lmdb_max_dbs, config1.deprecated_lmdb_max_dbs); } TEST (node_config, v17_values) @@ -950,7 +949,7 @@ TEST (json, backup) }; auto get_file_count = [&dir] () { - return std::count_if (boost::filesystem::directory_iterator (dir), boost::filesystem::directory_iterator (), static_cast (boost::filesystem::is_regular_file)); + return std::count_if (boost::filesystem::directory_iterator (dir), boost::filesystem::directory_iterator (), static_cast (boost::filesystem::is_regular_file)); }; // There should only be the original file in this directory @@ -1024,7 +1023,7 @@ TEST (node_flags, disable_udp) ASSERT_EQ (nano::endpoint (boost::asio::ip::address_v6::loopback (), 0), node2->network.udp_channels.get_local_endpoint ()); ASSERT_NE (nano::endpoint (boost::asio::ip::address_v6::loopback (), 0), node2->network.endpoint ()); // Send UDP message - auto channel (std::make_shared (node1->network.udp_channels, node2->network.endpoint (), node2->network_params.protocol.protocol_version)); + auto channel (std::make_shared (node1->network.udp_channels, node2->network.endpoint (), node2->network_params.network.protocol_version)); node1->network.send_keepalive (channel); std::this_thread::sleep_for (std::chrono::milliseconds (500)); // Check empty network @@ -1051,24 +1050,23 @@ TEST (node, fork_publish) nano::system system (1); node0 = system.nodes[0]; auto & node1 (*system.nodes[0]); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key1; - nano::genesis genesis; nano::send_block_builder builder; auto send1 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key1.pub) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) .build_shared (); node1.work_generate_blocking (*send1); nano::keypair key2; auto send2 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key2.pub) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) .build_shared (); node1.work_generate_blocking (*send2); @@ -1083,12 +1081,12 @@ TEST (node, fork_publish) node1.process_active (send2); node1.block_processor.flush (); auto votes1 (election->votes ()); - auto existing1 (votes1.find (nano::dev_genesis_key.pub)); + auto existing1 (votes1.find (nano::dev::genesis_key.pub)); ASSERT_NE (votes1.end (), existing1); ASSERT_EQ (send1->hash (), existing1->second.hash); auto winner (*election->tally ().begin ()); ASSERT_EQ (*send1, *winner.second); - ASSERT_EQ (nano::genesis_amount - 100, winner.first); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, winner.first); } ASSERT_TRUE (node0.expired ()); } @@ -1097,22 +1095,21 @@ TEST (node, fork_publish) TEST (node, fork_publish_inactive) { nano::system system (1); - nano::genesis genesis; nano::keypair key1; nano::keypair key2; nano::send_block_builder builder; auto send1 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key1.pub) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto send2 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key2.pub) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (send1->block_work ()) .build_shared (); auto & node = *system.nodes[0]; @@ -1136,22 +1133,21 @@ TEST (node, fork_keep) ASSERT_EQ (1, node1.network.size ()); nano::keypair key1; nano::keypair key2; - nano::genesis genesis; nano::send_block_builder builder; // send1 and send2 fork to different accounts auto send1 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key1.pub) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto send2 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key2.pub) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node1.process_active (send1); node1.block_processor.flush (); @@ -1161,12 +1157,12 @@ TEST (node, fork_keep) node2.scheduler.flush (); ASSERT_EQ (1, node1.active.size ()); ASSERT_EQ (1, node2.active.size ()); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); node1.process_active (send2); node1.block_processor.flush (); node2.process_active (send2); node2.block_processor.flush (); - auto election1 (node2.active.election (nano::qualified_root (genesis.hash (), genesis.hash ()))); + auto election1 (node2.active.election (nano::qualified_root (nano::dev::genesis->hash (), nano::dev::genesis->hash ()))); ASSERT_NE (nullptr, election1); ASSERT_EQ (1, election1->votes ().size ()); ASSERT_TRUE (node1.ledger.block_or_pruned_exists (send1->hash ())); @@ -1178,9 +1174,9 @@ TEST (node, fork_keep) // The vote should be in agreement with what we already have. auto winner (*election1->tally ().begin ()); ASSERT_EQ (*send1, *winner.second); - ASSERT_EQ (nano::genesis_amount - 100, winner.first); - ASSERT_TRUE (node1.store.block_exists (transaction0, send1->hash ())); - ASSERT_TRUE (node2.store.block_exists (transaction1, send1->hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, winner.first); + ASSERT_TRUE (node1.store.block.exists (transaction0, send1->hash ())); + ASSERT_TRUE (node2.store.block.exists (transaction1, send1->hash ())); } TEST (node, fork_flip) @@ -1190,41 +1186,40 @@ TEST (node, fork_flip) auto & node2 (*system.nodes[1]); ASSERT_EQ (1, node1.network.size ()); nano::keypair key1; - nano::genesis genesis; nano::send_block_builder builder; auto send1 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key1.pub) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - nano::publish publish1 (send1); + nano::publish publish1{ nano::dev::network_params.network, send1 }; nano::keypair key2; auto send2 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key2.pub) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - nano::publish publish2 (send2); + nano::publish publish2{ nano::dev::network_params.network, send2 }; auto channel1 (node1.network.udp_channels.create (node1.network.endpoint ())); - node1.network.process_message (publish1, channel1); + node1.network.inbound (publish1, channel1); node1.block_processor.flush (); node1.scheduler.flush (); auto channel2 (node2.network.udp_channels.create (node1.network.endpoint ())); - node2.network.process_message (publish2, channel2); + node2.network.inbound (publish2, channel2); node2.block_processor.flush (); node2.scheduler.flush (); ASSERT_EQ (1, node1.active.size ()); ASSERT_EQ (1, node2.active.size ()); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - node1.network.process_message (publish2, channel1); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + node1.network.inbound (publish2, channel1); node1.block_processor.flush (); - node2.network.process_message (publish1, channel2); + node2.network.inbound (publish1, channel2); node2.block_processor.flush (); - auto election1 (node2.active.election (nano::qualified_root (genesis.hash (), genesis.hash ()))); + auto election1 (node2.active.election (nano::qualified_root (nano::dev::genesis->hash (), nano::dev::genesis->hash ()))); ASSERT_NE (nullptr, election1); ASSERT_EQ (1, election1->votes ().size ()); ASSERT_NE (nullptr, node1.block (publish1.block->hash ())); @@ -1232,7 +1227,7 @@ TEST (node, fork_flip) ASSERT_TIMELY (10s, node2.ledger.block_or_pruned_exists (publish1.block->hash ())); auto winner (*election1->tally ().begin ()); ASSERT_EQ (*publish1.block, *winner.second); - ASSERT_EQ (nano::genesis_amount - 100, winner.first); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, winner.first); ASSERT_TRUE (node1.ledger.block_or_pruned_exists (publish1.block->hash ())); ASSERT_TRUE (node2.ledger.block_or_pruned_exists (publish1.block->hash ())); ASSERT_FALSE (node2.ledger.block_or_pruned_exists (publish2.block->hash ())); @@ -1258,49 +1253,48 @@ TEST (node, fork_multi_flip) auto & node2 (*system.add_node (node_config, node_flags, type)); ASSERT_EQ (1, node1.network.size ()); nano::keypair key1; - nano::genesis genesis; nano::send_block_builder builder; auto send1 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key1.pub) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - nano::publish publish1 (send1); + nano::publish publish1{ nano::dev::network_params.network, send1 }; nano::keypair key2; auto send2 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key2.pub) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - nano::publish publish2 (send2); + nano::publish publish2{ nano::dev::network_params.network, send2 }; auto send3 = builder.make_block () .previous (publish2.block->hash ()) .destination (key2.pub) - .balance (nano::genesis_amount - 100) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 100) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (publish2.block->hash ())) .build_shared (); - nano::publish publish3 (send3); - node1.network.process_message (publish1, node1.network.udp_channels.create (node1.network.endpoint ())); - node2.network.process_message (publish2, node2.network.udp_channels.create (node2.network.endpoint ())); - node2.network.process_message (publish3, node2.network.udp_channels.create (node2.network.endpoint ())); + nano::publish publish3{ nano::dev::network_params.network, send3 }; + node1.network.inbound (publish1, node1.network.udp_channels.create (node1.network.endpoint ())); + node2.network.inbound (publish2, node2.network.udp_channels.create (node2.network.endpoint ())); + node2.network.inbound (publish3, node2.network.udp_channels.create (node2.network.endpoint ())); node1.block_processor.flush (); node1.scheduler.flush (); node2.block_processor.flush (); node2.scheduler.flush (); ASSERT_EQ (1, node1.active.size ()); ASSERT_EQ (1, node2.active.size ()); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - node1.network.process_message (publish2, node1.network.udp_channels.create (node1.network.endpoint ())); - node1.network.process_message (publish3, node1.network.udp_channels.create (node1.network.endpoint ())); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + node1.network.inbound (publish2, node1.network.udp_channels.create (node1.network.endpoint ())); + node1.network.inbound (publish3, node1.network.udp_channels.create (node1.network.endpoint ())); node1.block_processor.flush (); - node2.network.process_message (publish1, node2.network.udp_channels.create (node2.network.endpoint ())); + node2.network.inbound (publish1, node2.network.udp_channels.create (node2.network.endpoint ())); node2.block_processor.flush (); - auto election1 (node2.active.election (nano::qualified_root (genesis.hash (), genesis.hash ()))); + auto election1 (node2.active.election (nano::qualified_root (nano::dev::genesis->hash (), nano::dev::genesis->hash ()))); ASSERT_NE (nullptr, election1); ASSERT_EQ (1, election1->votes ().size ()); ASSERT_TRUE (node1.ledger.block_or_pruned_exists (publish1.block->hash ())); @@ -1309,7 +1303,7 @@ TEST (node, fork_multi_flip) ASSERT_TIMELY (10s, node2.ledger.block_or_pruned_exists (publish1.block->hash ())); auto winner (*election1->tally ().begin ()); ASSERT_EQ (*publish1.block, *winner.second); - ASSERT_EQ (nano::genesis_amount - 100, winner.first); + ASSERT_EQ (nano::dev::constants.genesis_amount - 100, winner.first); ASSERT_TRUE (node1.ledger.block_or_pruned_exists (publish1.block->hash ())); ASSERT_TRUE (node2.ledger.block_or_pruned_exists (publish1.block->hash ())); ASSERT_FALSE (node2.ledger.block_or_pruned_exists (publish2.block->hash ())); @@ -1331,29 +1325,29 @@ TEST (node, fork_bootstrap_flip) auto & node1 = *system0.add_node (config0, node_flags); nano::node_config config1 (nano::get_available_port (), system1.logging); auto & node2 = *system1.add_node (config1, node_flags); - system0.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - nano::block_hash latest = node1.latest (nano::dev_genesis_key.pub); + system0.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + nano::block_hash latest = node1.latest (nano::dev::genesis_key.pub); nano::keypair key1; nano::send_block_builder builder; auto send1 = builder.make_block () .previous (latest) .destination (key1.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system0.work.generate (latest)) .build_shared (); nano::keypair key2; auto send2 = builder.make_block () .previous (latest) .destination (key2.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system0.work.generate (latest)) .build_shared (); // Insert but don't rebroadcast, simulating settled blocks ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code); ASSERT_EQ (nano::process_result::progress, node2.ledger.process (node2.store.tx_begin_write (), *send2).code); - ASSERT_TRUE (node2.store.block_exists (node2.store.tx_begin_read (), send2->hash ())); + ASSERT_TRUE (node2.store.block.exists (node2.store.tx_begin_read (), send2->hash ())); node2.bootstrap_initiator.bootstrap (node1.network.endpoint ()); // Additionally add new peer to confirm & replace bootstrap block auto again (true); system1.deadline_set (50s); @@ -1361,7 +1355,7 @@ TEST (node, fork_bootstrap_flip) { ASSERT_NO_ERROR (system0.poll ()); ASSERT_NO_ERROR (system1.poll ()); - again = !node2.store.block_exists (node2.store.tx_begin_read (), send1->hash ()); + again = !node2.store.block.exists (node2.store.tx_begin_read (), send1->hash ()); } } @@ -1370,17 +1364,16 @@ TEST (node, fork_open) nano::system system (1); auto & node1 (*system.nodes[0]); nano::keypair key1; - nano::genesis genesis; auto send1 = nano::send_block_builder () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key1.pub) .balance (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); - nano::publish publish1 (send1); + nano::publish publish1{ nano::dev::network_params.network, send1 }; auto channel1 (node1.network.udp_channels.create (node1.network.endpoint ())); - node1.network.process_message (publish1, channel1); + node1.network.inbound (publish1, channel1); node1.block_processor.flush (); node1.scheduler.flush (); auto election = node1.active.election (publish1.block->qualified_root ()); @@ -1395,8 +1388,8 @@ TEST (node, fork_open) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build_shared (); - nano::publish publish2 (open1); - node1.network.process_message (publish2, channel1); + nano::publish publish2{ nano::dev::network_params.network, open1 }; + node1.network.inbound (publish2, channel1); node1.block_processor.flush (); node1.scheduler.flush (); ASSERT_EQ (1, node1.active.size ()); @@ -1407,9 +1400,9 @@ TEST (node, fork_open) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1.pub)) .build_shared (); - nano::publish publish3 (open2); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - node1.network.process_message (publish3, channel1); + nano::publish publish3{ nano::dev::network_params.network, open2 }; + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + node1.network.inbound (publish3, channel1); node1.block_processor.flush (); node1.scheduler.flush (); election = node1.active.election (publish3.block->qualified_root ()); @@ -1427,15 +1420,14 @@ TEST (node, fork_open_flip) auto & node2 (*system.nodes[1]); ASSERT_EQ (1, node1.network.size ()); nano::keypair key1; - nano::genesis genesis; nano::keypair rep1; nano::keypair rep2; auto send1 = nano::send_block_builder () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key1.pub) - .balance (nano::genesis_amount - 1) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .balance (nano::dev::constants.genesis_amount - 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); // A copy is necessary to avoid data races during ledger processing, which sets the sideband auto send1_copy (std::make_shared (*send1)); @@ -1469,7 +1461,7 @@ TEST (node, fork_open_flip) node2.block_confirm (open2); ASSERT_EQ (2, node1.active.size ()); ASSERT_EQ (2, node2.active.size ()); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // Notify both nodes that a fork exists node1.process_active (open2); node1.block_processor.flush (); @@ -1487,23 +1479,23 @@ TEST (node, fork_open_flip) auto transaction2 (node2.store.tx_begin_read ()); auto winner (*election1->tally ().begin ()); ASSERT_EQ (*open1, *winner.second); - ASSERT_EQ (nano::genesis_amount - 1, winner.first); - ASSERT_TRUE (node1.store.block_exists (transaction1, open1->hash ())); - ASSERT_TRUE (node2.store.block_exists (transaction2, open1->hash ())); - ASSERT_FALSE (node2.store.block_exists (transaction2, open2->hash ())); + ASSERT_EQ (nano::dev::constants.genesis_amount - 1, winner.first); + ASSERT_TRUE (node1.store.block.exists (transaction1, open1->hash ())); + ASSERT_TRUE (node2.store.block.exists (transaction2, open1->hash ())); + ASSERT_FALSE (node2.store.block.exists (transaction2, open2->hash ())); } TEST (node, coherent_observer) { nano::system system (1); auto & node1 (*system.nodes[0]); - node1.observers.blocks.add ([&node1] (nano::election_status const & status_a, std::vector const &, nano::account const &, nano::uint128_t const &, bool) { + node1.observers.blocks.add ([&node1] (nano::election_status const & status_a, std::vector const &, nano::account const &, nano::uint128_t const &, bool, bool) { auto transaction (node1.store.tx_begin_read ()); - ASSERT_TRUE (node1.store.block_exists (transaction, status_a.winner->hash ())); + ASSERT_TRUE (node1.store.block.exists (transaction, status_a.winner->hash ())); }); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key; - system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 1); + system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 1); } TEST (node, fork_no_vote_quorum) @@ -1512,21 +1504,21 @@ TEST (node, fork_no_vote_quorum) auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); auto & node3 (*system.nodes[2]); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto key4 (system.wallet (0)->deterministic_insert ()); - system.wallet (0)->send_action (nano::dev_genesis_key.pub, key4, nano::genesis_amount / 4); + system.wallet (0)->send_action (nano::dev::genesis_key.pub, key4, nano::dev::constants.genesis_amount / 4); auto key1 (system.wallet (1)->deterministic_insert ()); { auto transaction (system.wallet (1)->wallets.tx_begin_write ()); system.wallet (1)->store.representative_set (transaction, key1); } - auto block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key1, node1.config.receive_minimum.number ())); + auto block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1, node1.config.receive_minimum.number ())); ASSERT_NE (nullptr, block); ASSERT_TIMELY (30s, node3.balance (key1) == node1.config.receive_minimum.number () && node2.balance (key1) == node1.config.receive_minimum.number () && node1.balance (key1) == node1.config.receive_minimum.number ()); ASSERT_EQ (node1.config.receive_minimum.number (), node1.weight (key1)); ASSERT_EQ (node1.config.receive_minimum.number (), node2.weight (key1)); ASSERT_EQ (node1.config.receive_minimum.number (), node3.weight (key1)); - nano::state_block send1 (nano::dev_genesis_key.pub, block->hash (), nano::dev_genesis_key.pub, (nano::genesis_amount / 4) - (node1.config.receive_minimum.number () * 2), key1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (block->hash ())); + nano::state_block send1 (nano::dev::genesis_key.pub, block->hash (), nano::dev::genesis_key.pub, (nano::dev::constants.genesis_amount / 4) - (node1.config.receive_minimum.number () * 2), key1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (block->hash ())); ASSERT_EQ (nano::process_result::progress, node1.process (send1).code); ASSERT_EQ (nano::process_result::progress, node2.process (send1).code); ASSERT_EQ (nano::process_result::progress, node3.process (send1).code); @@ -1534,15 +1526,15 @@ TEST (node, fork_no_vote_quorum) auto send2 = nano::send_block_builder () .previous (block->hash ()) .destination (key2) - .balance ((nano::genesis_amount / 4) - (node1.config.receive_minimum.number () * 2)) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance ((nano::dev::constants.genesis_amount / 4) - (node1.config.receive_minimum.number () * 2)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (block->hash ())) .build_shared (); nano::raw_key key3; auto transaction (system.wallet (1)->wallets.tx_begin_read ()); ASSERT_FALSE (system.wallet (1)->store.fetch (transaction, key1, key3)); - auto vote (std::make_shared (key1, key3, 0, send2)); - nano::confirm_ack confirm (vote); + auto vote (std::make_shared (key1, key3, 0, 0, send2)); + nano::confirm_ack confirm{ nano::dev::network_params.network, vote }; std::vector buffer; { nano::vectorstream stream (buffer); @@ -1552,9 +1544,9 @@ TEST (node, fork_no_vote_quorum) ASSERT_NE (nullptr, channel); channel->send_buffer (nano::shared_const_buffer (std::move (buffer))); ASSERT_TIMELY (10s, node3.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::in) >= 3); - ASSERT_TRUE (node1.latest (nano::dev_genesis_key.pub) == send1.hash ()); - ASSERT_TRUE (node2.latest (nano::dev_genesis_key.pub) == send1.hash ()); - ASSERT_TRUE (node3.latest (nano::dev_genesis_key.pub) == send1.hash ()); + ASSERT_TRUE (node1.latest (nano::dev::genesis_key.pub) == send1.hash ()); + ASSERT_TRUE (node2.latest (nano::dev::genesis_key.pub) == send1.hash ()); + ASSERT_TRUE (node3.latest (nano::dev::genesis_key.pub) == send1.hash ()); } // Disabled because it sometimes takes way too long (but still eventually finishes) @@ -1564,8 +1556,7 @@ TEST (node, DISABLED_fork_pre_confirm) auto & node0 (*system.nodes[0]); auto & node1 (*system.nodes[1]); auto & node2 (*system.nodes[2]); - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key1; system.wallet (1)->insert_adhoc (key1.prv); { @@ -1578,31 +1569,31 @@ TEST (node, DISABLED_fork_pre_confirm) auto transaction (system.wallet (2)->wallets.tx_begin_write ()); system.wallet (2)->store.representative_set (transaction, key2.pub); } - auto block0 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key1.pub, nano::genesis_amount / 3)); + auto block0 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, nano::dev::constants.genesis_amount / 3)); ASSERT_NE (nullptr, block0); ASSERT_TIMELY (30s, node0.balance (key1.pub) != 0); - auto block1 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, nano::genesis_amount / 3)); + auto block1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, nano::dev::constants.genesis_amount / 3)); ASSERT_NE (nullptr, block1); ASSERT_TIMELY (30s, node0.balance (key2.pub) != 0); nano::keypair key3; nano::keypair key4; nano::state_block_builder builder; auto block2 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (node0.latest (nano::dev_genesis_key.pub)) + .account (nano::dev::genesis_key.pub) + .previous (node0.latest (nano::dev::genesis_key.pub)) .representative (key3.pub) - .balance (node0.balance (nano::dev_genesis_key.pub)) + .balance (node0.balance (nano::dev::genesis_key.pub)) .link (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) .build_shared (); auto block3 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (node0.latest (nano::dev_genesis_key.pub)) + .account (nano::dev::genesis_key.pub) + .previous (node0.latest (nano::dev::genesis_key.pub)) .representative (key4.pub) - .balance (node0.balance (nano::dev_genesis_key.pub)) + .balance (node0.balance (nano::dev::genesis_key.pub)) .link (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) .build_shared (); node0.work_generate_blocking (*block2); @@ -1615,8 +1606,8 @@ TEST (node, DISABLED_fork_pre_confirm) system.deadline_set (70s); while (!done) { - done |= node0.latest (nano::dev_genesis_key.pub) == block2->hash () && node1.latest (nano::dev_genesis_key.pub) == block2->hash () && node2.latest (nano::dev_genesis_key.pub) == block2->hash (); - done |= node0.latest (nano::dev_genesis_key.pub) == block3->hash () && node1.latest (nano::dev_genesis_key.pub) == block3->hash () && node2.latest (nano::dev_genesis_key.pub) == block3->hash (); + done |= node0.latest (nano::dev::genesis_key.pub) == block2->hash () && node1.latest (nano::dev::genesis_key.pub) == block2->hash () && node2.latest (nano::dev::genesis_key.pub) == block2->hash (); + done |= node0.latest (nano::dev::genesis_key.pub) == block3->hash () && node1.latest (nano::dev::genesis_key.pub) == block3->hash () && node2.latest (nano::dev::genesis_key.pub) == block3->hash (); ASSERT_NO_ERROR (system.poll ()); } } @@ -1625,25 +1616,24 @@ TEST (node, DISABLED_fork_pre_confirm) TEST (node, DISABLED_fork_stale) { nano::system system1 (1); - system1.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system1.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::system system2 (1); auto & node1 (*system1.nodes[0]); auto & node2 (*system2.nodes[0]); node2.bootstrap_initiator.bootstrap (node1.network.endpoint (), false); - std::shared_ptr channel (std::make_shared (node2.network.udp_channels, node1.network.endpoint (), node2.network_params.protocol.protocol_version)); - auto vote = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, std::vector ()); + std::shared_ptr channel (std::make_shared (node2.network.udp_channels, node1.network.endpoint (), node2.network_params.network.protocol_version)); + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector ()); node2.rep_crawler.response (channel, vote); - nano::genesis genesis; nano::keypair key1; nano::keypair key2; nano::state_block_builder builder; auto send3 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::BAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::BAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) .build_shared (); node1.work_generate_blocking (*send3); @@ -1655,22 +1645,22 @@ TEST (node, DISABLED_fork_stale) ASSERT_NO_ERROR (system2.poll ()); } auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send3->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::BAN_ratio) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::BAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) .build_shared (); node1.work_generate_blocking (*send1); auto send2 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send3->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::BAN_ratio) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::BAN_ratio) .link (key2.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (0) .build_shared (); node1.work_generate_blocking (*send2); @@ -1692,7 +1682,10 @@ TEST (node, DISABLED_fork_stale) } } -TEST (node, broadcast_elected) +// Test disabled because it's failing intermittently. +// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3512 +// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3516 +TEST (node, DISABLED_broadcast_elected) { std::vector types{ nano::transport::transport_type::tcp, nano::transport::transport_type::udp }; for (auto & type : types) @@ -1721,11 +1714,11 @@ TEST (node, broadcast_elected) auto transaction1 (node1->store.tx_begin_write ()); auto transaction2 (node2->store.tx_begin_write ()); auto fund_big = *builder.send () - .previous (nano::genesis_hash) + .previous (nano::dev::genesis->hash ()) .destination (rep_big.pub) .balance (nano::MBAN_ratio * 5) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); auto open_big = *builder.open () .source (fund_big.hash ()) @@ -1738,7 +1731,7 @@ TEST (node, broadcast_elected) .previous (fund_big.hash ()) .destination (rep_small.pub) .balance (nano::MBAN_ratio * 2) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (fund_big.hash ())) .build (); auto open_small = *builder.open () @@ -1752,7 +1745,7 @@ TEST (node, broadcast_elected) .previous (fund_small.hash ()) .destination (rep_other.pub) .balance (nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (fund_small.hash ())) .build (); auto open_other = *builder.open () @@ -1784,7 +1777,7 @@ TEST (node, broadcast_elected) // Confirm blocks to allow voting for (auto & node : system.nodes) { - auto block (node->block (node->latest (nano::dev_genesis_key.pub))); + auto block (node->block (node->latest (nano::dev::genesis_key.pub))); ASSERT_NE (nullptr, block); node->block_confirm (block); auto election (node->active.election (block->qualified_root ())); @@ -1797,22 +1790,22 @@ TEST (node, broadcast_elected) system.wallet (1)->insert_adhoc (rep_small.prv); system.wallet (2)->insert_adhoc (rep_other.prv); auto fork0 = builder.send () - .previous (node2->latest (nano::dev_genesis_key.pub)) + .previous (node2->latest (nano::dev::genesis_key.pub)) .destination (rep_small.pub) .balance (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node0->work_generate_blocking (node2->latest (nano::dev_genesis_key.pub))) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (node2->latest (nano::dev::genesis_key.pub))) .build_shared (); // A copy is necessary to avoid data races during ledger processing, which sets the sideband auto fork0_copy (std::make_shared (*fork0)); node0->process_active (fork0); node1->process_active (fork0_copy); auto fork1 = builder.send () - .previous (node2->latest (nano::dev_genesis_key.pub)) + .previous (node2->latest (nano::dev::genesis_key.pub)) .destination (rep_big.pub) .balance (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node0->work_generate_blocking (node2->latest (nano::dev_genesis_key.pub))) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (node2->latest (nano::dev::genesis_key.pub))) .build_shared (); system.wallet (2)->insert_adhoc (rep_small.prv); node2->process_active (fork1); @@ -1839,11 +1832,11 @@ TEST (node, rep_self_vote) nano::keypair rep_big; nano::block_builder builder; auto fund_big = *builder.send () - .previous (nano::genesis_hash) + .previous (nano::dev::genesis->hash ()) .destination (rep_big.pub) .balance (nano::uint128_t{ "0xb0000000000000000000000000000000" }) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); auto open_big = *builder.open () .source (fund_big.hash ()) @@ -1861,26 +1854,26 @@ TEST (node, rep_self_vote) election->force_confirm (); system.wallet (0)->insert_adhoc (rep_big.prv); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_EQ (system.wallet (0)->wallets.reps ().voting, 2); auto block0 = builder.send () .previous (fund_big.hash ()) .destination (rep_big.pub) .balance (nano::uint128_t ("0x60000000000000000000000000000000")) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (fund_big.hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node0->process (*block0).code); auto & active = node0->active; auto & scheduler = node0->scheduler; - scheduler.activate (nano::dev_genesis_key.pub, node0->store.tx_begin_read ()); + scheduler.activate (nano::dev::genesis_key.pub, node0->store.tx_begin_read ()); scheduler.flush (); auto election1 = active.election (block0->qualified_root ()); ASSERT_NE (nullptr, election1); // Wait until representatives are activated & make vote ASSERT_TIMELY (1s, election1->votes ().size () == 3); auto rep_votes (election1->votes ()); - ASSERT_NE (rep_votes.end (), rep_votes.find (nano::dev_genesis_key.pub)); + ASSERT_NE (rep_votes.end (), rep_votes.find (nano::dev::genesis_key.pub)); ASSERT_NE (rep_votes.end (), rep_votes.find (rep_big.pub)); } @@ -1893,7 +1886,7 @@ TEST (node, DISABLED_bootstrap_no_publish) auto node1 (system1.nodes[0]); nano::keypair key0; // node0 knows about send0 but node1 doesn't. - nano::send_block send0 (node0->latest (nano::dev_genesis_key.pub), key0.pub, 500, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0); + nano::send_block send0 (node0->latest (nano::dev::genesis_key.pub), key0.pub, 500, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); { auto transaction (node0->store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, send0).code); @@ -1914,7 +1907,10 @@ TEST (node, DISABLED_bootstrap_no_publish) } // Check that an outgoing bootstrap request can push blocks -TEST (node, bootstrap_bulk_push) +// Test disabled because it's failing intermittently. +// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3512 +// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3515 +TEST (node, DISABLED_bootstrap_bulk_push) { nano::system system0; nano::system system1; @@ -1927,11 +1923,11 @@ TEST (node, bootstrap_bulk_push) nano::keypair key0; // node0 knows about send0 but node1 doesn't. auto send0 = nano::send_block_builder () - .previous (nano::genesis_hash) + .previous (nano::dev::genesis->hash ()) .destination (key0.pub) .balance (500) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node0->work_generate_blocking (nano::genesis_hash)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node0->process (*send0).code); @@ -1965,11 +1961,11 @@ TEST (node, bootstrap_fork_open) nano::keypair key0; nano::block_builder builder; auto send0 = *builder.send () - .previous (nano::genesis_hash) + .previous (nano::dev::genesis->hash ()) .destination (key0.pub) - .balance (nano::genesis_amount - 500) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .balance (nano::dev::constants.genesis_amount - 500) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); auto open0 = *builder.open () .source (send0.hash ()) @@ -1991,7 +1987,7 @@ TEST (node, bootstrap_fork_open) // Confirm send0 to allow starting and voting on the following blocks for (auto node : system.nodes) { - node->block_confirm (node->block (node->latest (nano::dev_genesis_key.pub))); + node->block_confirm (node->block (node->latest (nano::dev::genesis_key.pub))); ASSERT_TIMELY (1s, node->active.election (send0.qualified_root ())); auto election = node->active.election (send0.qualified_root ()); ASSERT_NE (nullptr, election); @@ -2002,7 +1998,7 @@ TEST (node, bootstrap_fork_open) // They disagree about open0/open1 ASSERT_EQ (nano::process_result::progress, node0->process (open0).code); ASSERT_EQ (nano::process_result::progress, node1->process (open1).code); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_FALSE (node1->ledger.block_or_pruned_exists (open0.hash ())); ASSERT_FALSE (node1->bootstrap_initiator.in_progress ()); node1->bootstrap_initiator.bootstrap (node0->network.endpoint (), false); @@ -2017,15 +2013,15 @@ TEST (node, bootstrap_confirm_frontiers) nano::system system1 (1); auto node0 (system0.nodes[0]); auto node1 (system1.nodes[0]); - system0.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system0.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key0; // node0 knows about send0 but node1 doesn't. auto send0 = nano::send_block_builder () - .previous (nano::genesis_hash) + .previous (nano::dev::genesis->hash ()) .destination (key0.pub) - .balance (nano::genesis_amount - 500) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node0->work_generate_blocking (nano::genesis_hash)) + .balance (nano::dev::constants.genesis_amount - 500) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node0->work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node0->process (*send0).code); @@ -2075,17 +2071,17 @@ TEST (node, DISABLED_unconfirmed_send) auto wallet1 (system.wallet (1)); nano::keypair key0; wallet1->insert_adhoc (key0.prv); - wallet0->insert_adhoc (nano::dev_genesis_key.prv); - auto send1 (wallet0->send_action (nano::genesis_account, key0.pub, 2 * nano::BAN_ratio)); + wallet0->insert_adhoc (nano::dev::genesis_key.prv); + auto send1 (wallet0->send_action (nano::dev::genesis->account (), key0.pub, 2 * nano::BAN_ratio)); ASSERT_TIMELY (10s, node1.balance (key0.pub) == 2 * nano::BAN_ratio && !node1.bootstrap_initiator.in_progress ()); auto latest (node1.latest (key0.pub)); - nano::state_block send2 (key0.pub, latest, nano::genesis_account, nano::BAN_ratio, nano::genesis_account, key0.prv, key0.pub, *node0.work_generate_blocking (latest)); + nano::state_block send2 (key0.pub, latest, nano::dev::genesis->account (), nano::BAN_ratio, nano::dev::genesis->account (), key0.prv, key0.pub, *node0.work_generate_blocking (latest)); { auto transaction (node1.store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, send2).code); } - auto send3 (wallet1->send_action (key0.pub, nano::genesis_account, nano::BAN_ratio)); - ASSERT_TIMELY (10s, node0.balance (nano::genesis_account) == nano::genesis_amount); + auto send3 (wallet1->send_action (key0.pub, nano::dev::genesis->account (), nano::BAN_ratio)); + ASSERT_TIMELY (10s, node0.balance (nano::dev::genesis->account ()) == nano::dev::constants.genesis_amount); } // Test that nodes can track nodes that have rep weight for priority broadcasting @@ -2096,10 +2092,10 @@ TEST (node, rep_list) auto wallet0 (system.wallet (0)); auto wallet1 (system.wallet (1)); // Node0 has a rep - wallet0->insert_adhoc (nano::dev_genesis_key.prv); + wallet0->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key1; // Broadcast a confirm so others should know this is a rep node - wallet0->send_action (nano::dev_genesis_key.pub, key1.pub, nano::BAN_ratio); + wallet0->send_action (nano::dev::genesis_key.pub, key1.pub, nano::BAN_ratio); ASSERT_EQ (0, node1.rep_crawler.representatives (1).size ()); system.deadline_set (10s); auto done (false); @@ -2130,7 +2126,6 @@ TEST (node, rep_weight) auto & node1 = *add_node (); auto & node2 = *add_node (); auto & node3 = *add_node (); - nano::genesis genesis; nano::keypair keypair1; nano::keypair keypair2; nano::block_builder builder; @@ -2138,13 +2133,13 @@ TEST (node, rep_weight) auto amount_not_pr (node.minimum_principal_weight () - 100); std::shared_ptr block1 = builder .state () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - amount_not_pr) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - amount_not_pr) .link (keypair1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); std::shared_ptr block2 = builder .state () @@ -2158,12 +2153,12 @@ TEST (node, rep_weight) .build (); std::shared_ptr block3 = builder .state () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (block1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - amount_not_pr - amount_pr) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - amount_not_pr - amount_pr) .link (keypair2.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (block1->hash ())) .build (); std::shared_ptr block4 = builder @@ -2190,9 +2185,9 @@ TEST (node, rep_weight) ASSERT_NE (nullptr, channel2); std::shared_ptr channel3 = nano::establish_tcp (system, node, node3.network.endpoint ()); ASSERT_NE (nullptr, channel3); - auto vote0 = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, genesis.open); - auto vote1 = std::make_shared (keypair1.pub, keypair1.prv, 0, genesis.open); - auto vote2 = std::make_shared (keypair2.pub, keypair2.prv, 0, genesis.open); + auto vote0 = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, nano::dev::genesis); + auto vote1 = std::make_shared (keypair1.pub, keypair1.prv, 0, 0, nano::dev::genesis); + auto vote2 = std::make_shared (keypair2.pub, keypair2.prv, 0, 0, nano::dev::genesis); node.rep_crawler.response (channel1, vote0); node.rep_crawler.response (channel2, vote1); node.rep_crawler.response (channel3, vote2); @@ -2200,8 +2195,8 @@ TEST (node, rep_weight) // Make sure we get the rep with the most weight first auto reps (node.rep_crawler.representatives (1)); ASSERT_EQ (1, reps.size ()); - ASSERT_EQ (node.balance (nano::dev_genesis_key.pub), reps[0].weight.number ()); - ASSERT_EQ (nano::dev_genesis_key.pub, reps[0].account); + ASSERT_EQ (node.balance (nano::dev::genesis_key.pub), reps[0].weight.number ()); + ASSERT_EQ (nano::dev::genesis_key.pub, reps[0].account); ASSERT_EQ (*channel1, reps[0].channel_ref ()); ASSERT_TRUE (node.rep_crawler.is_pr (*channel1)); ASSERT_FALSE (node.rep_crawler.is_pr (*channel2)); @@ -2214,19 +2209,18 @@ TEST (node, rep_remove) nano::node_flags node_flags; node_flags.disable_udp = false; auto & node = *system.add_node (node_flags); - nano::genesis genesis; nano::keypair keypair1; nano::keypair keypair2; nano::block_builder builder; std::shared_ptr block1 = builder .state () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - node.minimum_principal_weight () * 2) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - node.minimum_principal_weight () * 2) .link (keypair1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); std::shared_ptr block2 = builder .state () @@ -2240,12 +2234,12 @@ TEST (node, rep_remove) .build (); std::shared_ptr block3 = builder .state () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (block1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - node.minimum_principal_weight () * 4) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - node.minimum_principal_weight () * 4) .link (keypair2.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (block1->hash ())) .build (); std::shared_ptr block4 = builder @@ -2267,9 +2261,9 @@ TEST (node, rep_remove) } // Add inactive UDP representative channel nano::endpoint endpoint0 (boost::asio::ip::address_v6::loopback (), nano::get_available_port ()); - std::shared_ptr channel0 (std::make_shared (node.network.udp_channels, endpoint0, node.network_params.protocol.protocol_version)); - auto channel_udp = node.network.udp_channels.insert (endpoint0, node.network_params.protocol.protocol_version); - auto vote1 = std::make_shared (keypair1.pub, keypair1.prv, 0, genesis.open); + std::shared_ptr channel0 (std::make_shared (node.network.udp_channels, endpoint0, node.network_params.network.protocol_version)); + auto channel_udp = node.network.udp_channels.insert (endpoint0, node.network_params.network.protocol_version); + auto vote1 = std::make_shared (keypair1.pub, keypair1.prv, 0, 0, nano::dev::genesis); ASSERT_FALSE (node.rep_crawler.response (channel0, vote1)); ASSERT_TIMELY (5s, node.rep_crawler.representative_count () == 1); auto reps (node.rep_crawler.representatives (1)); @@ -2287,27 +2281,25 @@ TEST (node, rep_remove) ASSERT_TIMELY (10s, node.rep_crawler.representative_count () == 0); // Add working representative auto node1 = system.add_node (nano::node_config (nano::get_available_port (), system.logging)); - system.wallet (1)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); auto channel1 (node.network.find_channel (node1->network.endpoint ())); ASSERT_NE (nullptr, channel1); - auto vote2 = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, genesis.open); + auto vote2 = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, nano::dev::genesis); node.rep_crawler.response (channel1, vote2); ASSERT_TIMELY (10s, node.rep_crawler.representative_count () == 1); - // Add inactive TCP representative channel auto node2 (std::make_shared (system.io_ctx, nano::unique_path (), nano::node_config (nano::get_available_port (), system.logging), system.work)); + node2->start (); std::weak_ptr node_w (node.shared ()); - auto vote3 = std::make_shared (keypair2.pub, keypair2.prv, 0, genesis.open); - node.network.tcp_channels.start_tcp (node2->network.endpoint (), [node_w, &vote3] (std::shared_ptr const & channel2) { - if (auto node_l = node_w.lock ()) - { - ASSERT_FALSE (node_l->rep_crawler.response (channel2, vote3)); - } - }); + auto vote3 = std::make_shared (keypair2.pub, keypair2.prv, 0, 0, nano::dev::genesis); + node.network.tcp_channels.start_tcp (node2->network.endpoint ()); + std::shared_ptr channel2; + ASSERT_TIMELY (10s, (channel2 = node.network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node2->network.endpoint ()))) != nullptr); + ASSERT_FALSE (node.rep_crawler.response (channel2, vote3)); ASSERT_TIMELY (10s, node.rep_crawler.representative_count () == 2); node2->stop (); ASSERT_TIMELY (10s, node.rep_crawler.representative_count () == 1); reps = node.rep_crawler.representatives (1); - ASSERT_EQ (nano::dev_genesis_key.pub, reps[0].account); + ASSERT_EQ (nano::dev::genesis_key.pub, reps[0].account); ASSERT_EQ (1, node.network.size ()); auto list (node.network.list (1)); ASSERT_EQ (node1->network.endpoint (), list[0]->get_endpoint ()); @@ -2319,7 +2311,7 @@ TEST (node, rep_connection_close) auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); // Add working representative (node 2) - system.wallet (1)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_TIMELY (10s, node1.rep_crawler.representative_count () == 1); node2.stop (); // Remove representative with closed channel @@ -2338,11 +2330,11 @@ TEST (node, no_voting) auto wallet0 (system.wallet (0)); auto wallet1 (system.wallet (1)); // Node1 has a rep - wallet1->insert_adhoc (nano::dev_genesis_key.prv); + wallet1->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key1; wallet1->insert_adhoc (key1.prv); // Broadcast a confirm so others should know this is a rep node - wallet1->send_action (nano::dev_genesis_key.pub, key1.pub, nano::BAN_ratio); + wallet1->send_action (nano::dev::genesis_key.pub, key1.pub, nano::BAN_ratio); ASSERT_TIMELY (10s, node0.active.empty ()); ASSERT_EQ (0, node0.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::in)); } @@ -2352,14 +2344,14 @@ TEST (node, send_callback) nano::system system (1); auto & node0 (*system.nodes[0]); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key2.prv); node0.config.callback_address = "localhost"; node0.config.callback_port = 8010; node0.config.callback_target = "/"; - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, node0.config.receive_minimum.number ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, node0.config.receive_minimum.number ())); ASSERT_TIMELY (10s, node0.balance (key2.pub).is_zero ()); - ASSERT_EQ (std::numeric_limits::max () - node0.config.receive_minimum.number (), node0.balance (nano::dev_genesis_key.pub)); + ASSERT_EQ (std::numeric_limits::max () - node0.config.receive_minimum.number (), node0.balance (nano::dev::genesis_key.pub)); } TEST (node, balance_observer) @@ -2373,13 +2365,13 @@ TEST (node, balance_observer) { balances++; } - else if (nano::dev_genesis_key.pub == account_a && !is_pending) + else if (nano::dev::genesis_key.pub == account_a && !is_pending) { balances++; } }); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 1); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 1); system.deadline_set (10s); auto done (false); while (!done) @@ -2479,12 +2471,12 @@ TEST (node, online_reps) ASSERT_EQ (node1.config.online_weight_minimum, node1.online_reps.trended ()); auto vote (std::make_shared ()); ASSERT_EQ (0, node1.online_reps.online ()); - node1.online_reps.observe (nano::dev_genesis_key.pub); - ASSERT_EQ (nano::genesis_amount, node1.online_reps.online ()); + node1.online_reps.observe (nano::dev::genesis_key.pub); + ASSERT_EQ (nano::dev::constants.genesis_amount, node1.online_reps.online ()); // 1 minimum, 1 maximum ASSERT_EQ (node1.config.online_weight_minimum, node1.online_reps.trended ()); node1.online_reps.sample (); - ASSERT_EQ (nano::genesis_amount, node1.online_reps.trended ()); + ASSERT_EQ (nano::dev::constants.genesis_amount, node1.online_reps.trended ()); node1.online_reps.clear (); // 2 minimum, 1 maximum node1.online_reps.sample (); @@ -2499,7 +2491,7 @@ TEST (node, online_reps_rep_crawler) nano::node_flags flags; flags.disable_rep_crawler = true; auto & node1 = *system.add_node (flags); - auto vote = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), std::vector{ nano::genesis_hash }); + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::milliseconds_since_epoch (), 0, std::vector{ nano::dev::genesis->hash () }); ASSERT_EQ (0, node1.online_reps.online ()); // Without rep crawler node1.vote_processor.vote_blocking (vote, std::make_shared (node1)); @@ -2507,10 +2499,10 @@ TEST (node, online_reps_rep_crawler) // After inserting to rep crawler { nano::lock_guard guard (node1.rep_crawler.probable_reps_mutex); - node1.rep_crawler.active.insert (nano::genesis_hash); + node1.rep_crawler.active.insert (nano::dev::genesis->hash ()); } node1.vote_processor.vote_blocking (vote, std::make_shared (node1)); - ASSERT_EQ (nano::genesis_amount, node1.online_reps.online ()); + ASSERT_EQ (nano::dev::constants.genesis_amount, node1.online_reps.online ()); } } @@ -2521,27 +2513,26 @@ TEST (node, online_reps_election) flags.disable_rep_crawler = true; auto & node1 = *system.add_node (flags); // Start election - nano::genesis genesis; nano::keypair key; nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node1.work_generate_blocking (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); node1.process_active (send1); node1.block_processor.flush (); node1.scheduler.flush (); ASSERT_EQ (1, node1.active.size ()); // Process vote for ongoing election - auto vote = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), std::vector{ send1->hash () }); + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::milliseconds_since_epoch (), 0, std::vector{ send1->hash () }); ASSERT_EQ (0, node1.online_reps.online ()); node1.vote_processor.vote_blocking (vote, std::make_shared (node1)); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio, node1.online_reps.online ()); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, node1.online_reps.online ()); } TEST (node, block_confirm) @@ -2559,18 +2550,17 @@ TEST (node, block_confirm) nano::system system (2, type, node_flags); auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); - nano::genesis genesis; nano::keypair key; nano::state_block_builder builder; - system.wallet (1)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node1.work_generate_blocking (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); // A copy is necessary to avoid data races during ledger processing, which sets the sideband auto send1_copy = builder.make_block () @@ -2640,27 +2630,26 @@ TEST (node, confirm_quorum) { nano::system system (1); auto & node1 = *system.nodes[0]; - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // Put greater than node.delta () in pending so quorum can't be reached nano::amount new_balance = node1.online_reps.delta () - nano::MBAN_ratio; auto send1 = nano::state_block_builder () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .balance (new_balance) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node1.work_generate_blocking (genesis.hash ())) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); - system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, new_balance.number ()); + system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, new_balance.number ()); ASSERT_TIMELY (2s, node1.active.election (send1->qualified_root ())); auto election = node1.active.election (send1->qualified_root ()); ASSERT_NE (nullptr, election); ASSERT_FALSE (election->confirmed ()); ASSERT_EQ (1, election->votes ().size ()); - ASSERT_EQ (0, node1.balance (nano::dev_genesis_key.pub)); + ASSERT_EQ (0, node1.balance (nano::dev::genesis_key.pub)); } TEST (node, local_votes_cache) @@ -2668,35 +2657,34 @@ TEST (node, local_votes_cache) nano::system system; nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; - node_config.receive_minimum = nano::genesis_amount; + node_config.receive_minimum = nano::dev::constants.genesis_amount; auto & node (*system.add_node (node_config)); - nano::genesis genesis; nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node.work_generate_blocking (genesis.hash ())) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); auto send2 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) .build_shared (); auto send3 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send2->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 3 * nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 3 * nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send2->hash ())) .build_shared (); { @@ -2710,18 +2698,18 @@ TEST (node, local_votes_cache) ASSERT_NE (nullptr, election); election->force_confirm (); ASSERT_TIMELY (3s, node.ledger.cache.cemented_count == 3); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - nano::confirm_req message1 (send1); - nano::confirm_req message2 (send2); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + nano::confirm_req message1{ nano::dev::network_params.network, send1 }; + nano::confirm_req message2{ nano::dev::network_params.network, send2 }; auto channel (node.network.udp_channels.create (node.network.endpoint ())); - node.network.process_message (message1, channel); + node.network.inbound (message1, channel); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_generated_votes) == 1); - node.network.process_message (message2, channel); + node.network.inbound (message2, channel); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_generated_votes) == 2); for (auto i (0); i < 100; ++i) { - node.network.process_message (message1, channel); - node.network.process_message (message2, channel); + node.network.inbound (message1, channel); + node.network.inbound (message2, channel); } for (int i = 0; i < 4; ++i) { @@ -2734,10 +2722,10 @@ TEST (node, local_votes_cache) auto transaction (node.store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node.ledger.process (transaction, *send3).code); } - nano::confirm_req message3 (send3); + nano::confirm_req message3{ nano::dev::network_params.network, send3 }; for (auto i (0); i < 100; ++i) { - node.network.process_message (message3, channel); + node.network.inbound (message3, channel); } for (int i = 0; i < 4; ++i) { @@ -2749,42 +2737,44 @@ TEST (node, local_votes_cache) ASSERT_FALSE (node.history.votes (send3->root (), send3->hash ()).empty ()); } -TEST (node, local_votes_cache_batch) +// Test disabled because it's failing intermittently. +// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3532 +// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3481 +TEST (node, DISABLED_local_votes_cache_batch) { nano::system system; nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node (*system.add_node (node_config)); ASSERT_GE (node.network_params.voting.max_cache, 2); - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key1; auto send1 = nano::state_block_builder () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node.work_generate_blocking (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); node.confirmation_height_processor.add (send1); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); auto send2 = nano::state_block_builder () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code); auto receive1 = nano::state_block_builder () .account (key1.pub) .previous (0) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (nano::MBAN_ratio) .link (send1->hash ()) .sign (key1.prv, key1.pub) @@ -2792,29 +2782,29 @@ TEST (node, local_votes_cache_batch) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *receive1).code); std::vector> batch{ { send2->hash (), send2->root () }, { receive1->hash (), receive1->root () } }; - nano::confirm_req message (batch); + nano::confirm_req message{ nano::dev::network_params.network, batch }; auto channel (node.network.udp_channels.create (node.network.endpoint ())); // Generates and sends one vote for both hashes which is then cached - node.network.process_message (message, channel); + node.network.inbound (message, channel); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out) == 1); ASSERT_EQ (1, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); ASSERT_FALSE (node.history.votes (send2->root (), send2->hash ()).empty ()); ASSERT_FALSE (node.history.votes (receive1->root (), receive1->hash ()).empty ()); // Only one confirm_ack should be sent if all hashes are part of the same vote - node.network.process_message (message, channel); + node.network.inbound (message, channel); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out) == 2); ASSERT_EQ (2, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); // Test when votes are different node.history.erase (send2->root ()); node.history.erase (receive1->root ()); - node.network.process_message (nano::confirm_req (send2->hash (), send2->root ()), channel); + node.network.inbound (nano::confirm_req{ nano::dev::network_params.network, send2->hash (), send2->root () }, channel); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out) == 3); ASSERT_EQ (3, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); - node.network.process_message (nano::confirm_req (receive1->hash (), receive1->root ()), channel); + node.network.inbound (nano::confirm_req{ nano::dev::network_params.network, receive1->hash (), receive1->root () }, channel); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out) == 4); ASSERT_EQ (4, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); // There are two different votes, so both should be sent in response - node.network.process_message (message, channel); + node.network.inbound (message, channel); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out) == 6); ASSERT_EQ (6, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); } @@ -2825,38 +2815,37 @@ TEST (node, local_votes_cache_generate_new_vote) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node (*system.add_node (node_config)); - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // Repsond with cached vote - nano::confirm_req message1 (genesis.open); + nano::confirm_req message1{ nano::dev::network_params.network, nano::dev::genesis }; auto channel (node.network.udp_channels.create (node.network.endpoint ())); - node.network.process_message (message1, channel); - ASSERT_TIMELY (3s, !node.history.votes (genesis.open->root (), genesis.open->hash ()).empty ()); - auto votes1 (node.history.votes (genesis.open->root (), genesis.open->hash ())); + node.network.inbound (message1, channel); + ASSERT_TIMELY (3s, !node.history.votes (nano::dev::genesis->root (), nano::dev::genesis->hash ()).empty ()); + auto votes1 (node.history.votes (nano::dev::genesis->root (), nano::dev::genesis->hash ())); ASSERT_EQ (1, votes1.size ()); ASSERT_EQ (1, votes1[0]->blocks.size ()); - ASSERT_EQ (genesis.open->hash (), boost::get (votes1[0]->blocks[0])); + ASSERT_EQ (nano::dev::genesis->hash (), boost::get (votes1[0]->blocks[0])); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_generated_votes) == 1); auto send1 = nano::state_block_builder () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node.work_generate_blocking (genesis.hash ())) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.process (*send1).code); // One of the hashes is cached - std::vector> roots_hashes{ std::make_pair (genesis.open->hash (), genesis.open->root ()), std::make_pair (send1->hash (), send1->root ()) }; - nano::confirm_req message2 (roots_hashes); - node.network.process_message (message2, channel); + std::vector> roots_hashes{ std::make_pair (nano::dev::genesis->hash (), nano::dev::genesis->root ()), std::make_pair (send1->hash (), send1->root ()) }; + nano::confirm_req message2{ nano::dev::network_params.network, roots_hashes }; + node.network.inbound (message2, channel); ASSERT_TIMELY (3s, !node.history.votes (send1->root (), send1->hash ()).empty ()); auto votes2 (node.history.votes (send1->root (), send1->hash ())); ASSERT_EQ (1, votes2.size ()); ASSERT_EQ (1, votes2[0]->blocks.size ()); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::requests, nano::stat::detail::requests_generated_votes) == 2); - ASSERT_FALSE (node.history.votes (genesis.open->root (), genesis.open->hash ()).empty ()); + ASSERT_FALSE (node.history.votes (nano::dev::genesis->root (), nano::dev::genesis->hash ()).empty ()); ASSERT_FALSE (node.history.votes (send1->root (), send1->hash ()).empty ()); // First generated + again cached + new generated ASSERT_TIMELY (3s, 3 == node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); @@ -2875,29 +2864,28 @@ TEST (node, local_votes_cache_fork) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node1 (*system.add_node (node_config, node_flags)); - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto send1 = nano::state_block_builder () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node1.work_generate_blocking (genesis.hash ())) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); auto send1_fork = nano::state_block_builder () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node1.work_generate_blocking (genesis.hash ())) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1.process (*send1).code); // Cache vote - auto vote (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, std::vector (1, send1->hash ()))); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector (1, send1->hash ()))); node1.vote_processor.vote (vote, std::make_shared (node1)); node1.history.add (send1->root (), send1->hash (), vote); auto votes2 (node1.history.votes (send1->root (), send1->hash ())); @@ -2917,29 +2905,29 @@ TEST (node, vote_republish) auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); nano::keypair key2; + // by not setting a private key on node1's wallet, it is stopped from voting system.wallet (1)->insert_adhoc (key2.prv); - nano::genesis genesis; nano::send_block_builder builder; auto send1 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key2.pub) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number ()) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto send2 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key2.pub) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number () * 2) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node1.process_active (send1); ASSERT_TIMELY (5s, node2.block (send1->hash ())); - node1.active.publish (send2); - auto vote (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), send2)); + node1.process_active (send2); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, send2)); ASSERT_TRUE (node1.active.active (*send1)); - ASSERT_TRUE (node2.active.active (*send1)); + ASSERT_TIMELY (10s, node2.active.active (*send1)); node1.vote_processor.vote (vote, std::make_shared (node1)); ASSERT_TIMELY (10s, node1.block (send2->hash ())); ASSERT_TIMELY (10s, node2.block (send2->hash ())); @@ -2958,13 +2946,13 @@ TEST (node, vote_by_hash_bundle) nano::state_block_builder builder; std::vector> blocks; auto block = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 1) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 1) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); blocks.push_back (block); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *blocks.back ()).code); @@ -2973,8 +2961,8 @@ TEST (node, vote_by_hash_bundle) auto block = builder.make_block () .from (*blocks.back ()) .previous (blocks.back ()->hash ()) - .balance (nano::genesis_amount - i) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - i) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (blocks.back ()->hash ())) .build_shared (); blocks.push_back (block); @@ -2984,7 +2972,7 @@ TEST (node, vote_by_hash_bundle) auto election = node.active.election (blocks.back ()->qualified_root ()); ASSERT_NE (nullptr, election); election->force_confirm (); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key1; system.wallet (0)->insert_adhoc (key1.prv); @@ -3005,35 +2993,38 @@ TEST (node, vote_by_hash_bundle) ASSERT_TIMELY (20s, max_hashes.load () >= 3); } -TEST (node, vote_by_hash_republish) +// Test disabled because it's failing intermittently. +// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3556 +// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3557 +// CI run in which it failed: https://github.com/nanocurrency/nano-node/runs/4278407269?check_suite_focus=true#step:6:1144 +TEST (node, DISABLED_vote_by_hash_republish) { nano::system system{ 2 }; auto & node1 = *system.nodes[0]; auto & node2 = *system.nodes[1]; nano::keypair key2; system.wallet (1)->insert_adhoc (key2.prv); - nano::genesis genesis; nano::send_block_builder builder; auto send1 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key2.pub) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number ()) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto send2 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key2.pub) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number () * 2) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node1.process_active (send1); ASSERT_TIMELY (5s, node2.active.active (*send1)); node1.process_active (send2); std::vector vote_blocks; vote_blocks.push_back (send2->hash ()); - auto vote = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), vote_blocks); // Final vote for confirmation + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, vote_blocks); // Final vote for confirmation ASSERT_TRUE (node1.active.active (*send1)); ASSERT_TRUE (node2.active.active (*send1)); node1.vote_processor.vote (vote, std::make_shared (node1)); @@ -3052,29 +3043,28 @@ TEST (node, vote_by_hash_epoch_block_republish) auto & node2 (*system.nodes[1]); nano::keypair key2; system.wallet (1)->insert_adhoc (key2.prv); - nano::genesis genesis; auto send1 = nano::send_block_builder () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key2.pub) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number ()) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto epoch1 = nano::state_block_builder () - .account (nano::genesis_account) - .previous (genesis.hash ()) - .representative (nano::genesis_account) - .balance (nano::genesis_amount) + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount) .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); node1.process_active (send1); ASSERT_TIMELY (5s, node2.active.active (*send1)); node1.active.publish (epoch1); std::vector vote_blocks; vote_blocks.push_back (epoch1->hash ()); - auto vote (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, vote_blocks)); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, vote_blocks)); ASSERT_TRUE (node1.active.active (*send1)); ASSERT_TRUE (node2.active.active (*send1)); node1.vote_processor.vote (vote, std::make_shared (node1)); @@ -3093,17 +3083,16 @@ TEST (node, epoch_conflict_confirm) node_config.peering_port = nano::get_available_port (); auto node1 = system.add_node (node_config); nano::keypair key; - nano::genesis genesis; - nano::keypair epoch_signer (nano::dev_genesis_key); + nano::keypair epoch_signer (nano::dev::genesis_key); nano::state_block_builder builder; auto send = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 1) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 1) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto open = builder.make_block () .account (key.pub) @@ -3124,12 +3113,12 @@ TEST (node, epoch_conflict_confirm) .work (*system.work.generate (open->hash ())) .build_shared (); auto send2 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2) .link (open->hash ()) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send->hash ())) .build_shared (); auto epoch_open = builder.make_block () @@ -3167,17 +3156,20 @@ TEST (node, epoch_conflict_confirm) ASSERT_TRUE (node0->active.blocks.find (change->hash ()) != node0->active.blocks.end ()); ASSERT_TRUE (node0->active.blocks.find (epoch_open->hash ()) != node0->active.blocks.end ()); } - system.wallet (1)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_TIMELY (5s, node0->active.election (change->qualified_root ()) == nullptr); ASSERT_TIMELY (5s, node0->active.empty ()); { auto transaction (node0->store.tx_begin_read ()); - ASSERT_TRUE (node0->ledger.store.block_exists (transaction, change->hash ())); - ASSERT_TRUE (node0->ledger.store.block_exists (transaction, epoch_open->hash ())); + ASSERT_TRUE (node0->ledger.store.block.exists (transaction, change->hash ())); + ASSERT_TRUE (node0->ledger.store.block.exists (transaction, epoch_open->hash ())); } } -TEST (node, fork_invalid_block_signature) +// Test disabled because it's failing intermittently. +// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3526 +// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3527 +TEST (node, DISABLED_fork_invalid_block_signature) { nano::system system; nano::node_flags node_flags; @@ -3190,26 +3182,25 @@ TEST (node, fork_invalid_block_signature) auto & node1 (*system.add_node (node_flags)); auto & node2 (*system.add_node (node_flags)); nano::keypair key2; - nano::genesis genesis; nano::send_block_builder builder; auto send1 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key2.pub) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number ()) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto send2 = builder.make_block () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key2.pub) .balance (std::numeric_limits::max () - node1.config.receive_minimum.number () * 2) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto send2_corrupt (std::make_shared (*send2)); send2_corrupt->signature = nano::signature (123); - auto vote (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, send2)); - auto vote_corrupt (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, send2_corrupt)); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, send2)); + auto vote_corrupt (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, send2_corrupt)); node1.process_active (send1); ASSERT_TIMELY (5s, node1.block (send1->hash ())); @@ -3228,43 +3219,42 @@ TEST (node, fork_election_invalid_block_signature) { nano::system system (1); auto & node1 (*system.nodes[0]); - nano::genesis genesis; nano::block_builder builder; auto send1 = builder.state () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build_shared (); auto send2 = builder.state () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build_shared (); auto send3 = builder.state () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) - .sign (nano::dev_genesis_key.prv, 0) // Invalid signature + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .sign (nano::dev::genesis_key.prv, 0) // Invalid signature .build_shared (); auto channel1 (node1.network.udp_channels.create (node1.network.endpoint ())); - node1.network.process_message (nano::publish (send1), channel1); + node1.network.inbound (nano::publish{ nano::dev::network_params.network, send1 }, channel1); ASSERT_TIMELY (5s, node1.active.active (send1->qualified_root ())); auto election (node1.active.election (send1->qualified_root ())); ASSERT_NE (nullptr, election); ASSERT_EQ (1, election->blocks ().size ()); - node1.network.process_message (nano::publish (send3), channel1); - node1.network.process_message (nano::publish (send2), channel1); + node1.network.inbound (nano::publish{ nano::dev::network_params.network, send3 }, channel1); + node1.network.inbound (nano::publish{ nano::dev::network_params.network, send2 }, channel1); ASSERT_TIMELY (3s, election->blocks ().size () > 1); ASSERT_EQ (election->blocks ()[send2->hash ()]->block_signature (), send2->block_signature ()); } @@ -3273,70 +3263,70 @@ TEST (node, block_processor_signatures) { nano::system system0 (1); auto & node1 (*system0.nodes[0]); - system0.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - nano::block_hash latest (system0.nodes[0]->latest (nano::dev_genesis_key.pub)); + system0.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + nano::block_hash latest (system0.nodes[0]->latest (nano::dev::genesis_key.pub)); nano::state_block_builder builder; nano::keypair key1; nano::keypair key2; nano::keypair key3; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (latest) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (latest)) .build_shared (); auto send2 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) .link (key2.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (send1->hash ())) .build_shared (); auto send3 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send2->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 3 * nano::MBAN_ratio) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 3 * nano::MBAN_ratio) .link (key3.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (send2->hash ())) .build_shared (); // Invalid signature bit auto send4 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send3->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 4 * nano::MBAN_ratio) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 4 * nano::MBAN_ratio) .link (key3.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (send3->hash ())) .build_shared (); send4->signature.bytes[32] ^= 0x1; // Invalid signature bit (force) auto send5 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send3->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 5 * nano::MBAN_ratio) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 5 * nano::MBAN_ratio) .link (key3.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1.work_generate_blocking (send3->hash ())) .build_shared (); send5->signature.bytes[31] ^= 0x1; // Invalid signature to unchecked { auto transaction (node1.store.tx_begin_write ()); - node1.store.unchecked_put (transaction, send5->previous (), send5); + node1.store.unchecked.put (transaction, send5->previous (), send5); } auto receive1 = builder.make_block () .account (key1.pub) .previous (0) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (nano::MBAN_ratio) .link (send1->hash ()) .sign (key1.prv, key1.pub) @@ -3345,7 +3335,7 @@ TEST (node, block_processor_signatures) auto receive2 = builder.make_block () .account (key2.pub) .previous (0) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (nano::MBAN_ratio) .link (send2->hash ()) .sign (key2.prv, key2.pub) @@ -3355,7 +3345,7 @@ TEST (node, block_processor_signatures) auto receive3 = builder.make_block () .account (key3.pub) .previous (0) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (nano::MBAN_ratio) .link (send3->hash ()) .sign (key2.prv, key3.pub) @@ -3372,14 +3362,14 @@ TEST (node, block_processor_signatures) node1.block_processor.force (send5); node1.block_processor.flush (); auto transaction (node1.store.tx_begin_read ()); - ASSERT_TRUE (node1.store.block_exists (transaction, send1->hash ())); - ASSERT_TRUE (node1.store.block_exists (transaction, send2->hash ())); - ASSERT_TRUE (node1.store.block_exists (transaction, send3->hash ())); - ASSERT_FALSE (node1.store.block_exists (transaction, send4->hash ())); - ASSERT_FALSE (node1.store.block_exists (transaction, send5->hash ())); - ASSERT_TRUE (node1.store.block_exists (transaction, receive1->hash ())); - ASSERT_TRUE (node1.store.block_exists (transaction, receive2->hash ())); - ASSERT_FALSE (node1.store.block_exists (transaction, receive3->hash ())); + ASSERT_TRUE (node1.store.block.exists (transaction, send1->hash ())); + ASSERT_TRUE (node1.store.block.exists (transaction, send2->hash ())); + ASSERT_TRUE (node1.store.block.exists (transaction, send3->hash ())); + ASSERT_FALSE (node1.store.block.exists (transaction, send4->hash ())); + ASSERT_FALSE (node1.store.block.exists (transaction, send5->hash ())); + ASSERT_TRUE (node1.store.block.exists (transaction, receive1->hash ())); + ASSERT_TRUE (node1.store.block.exists (transaction, receive2->hash ())); + ASSERT_FALSE (node1.store.block.exists (transaction, receive3->hash ())); } /* @@ -3390,16 +3380,15 @@ TEST (node, block_processor_reject_state) { nano::system system (1); auto & node (*system.nodes[0]); - nano::genesis genesis; nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node.work_generate_blocking (genesis.hash ())) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); send1->signature.bytes[0] ^= 1; ASSERT_FALSE (node.ledger.block_or_pruned_exists (send1->hash ())); @@ -3408,13 +3397,13 @@ TEST (node, block_processor_reject_state) ASSERT_NE (std::future_status::timeout, flushed.wait_for (5s)); ASSERT_FALSE (node.ledger.block_or_pruned_exists (send1->hash ())); auto send2 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node.work_generate_blocking (genesis.hash ())) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); node.process_active (send2); auto flushed2 = std::async (std::launch::async, [&node] { node.block_processor.flush (); }); @@ -3429,33 +3418,32 @@ TEST (node, block_processor_full) node_flags.force_use_write_database_queue = true; node_flags.block_processor_full_size = 3; auto & node = *system.add_node (nano::node_config (nano::get_available_port (), system.logging), node_flags); - nano::genesis genesis; nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node.work_generate_blocking (genesis.hash ())) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); auto send2 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) .build_shared (); auto send3 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send2->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 3 * nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 3 * nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send2->hash ())) .build_shared (); // The write guard prevents block processor doing any writes @@ -3476,33 +3464,32 @@ TEST (node, block_processor_half_full) node_flags.block_processor_full_size = 6; node_flags.force_use_write_database_queue = true; auto & node = *system.add_node (nano::node_config (nano::get_available_port (), system.logging), node_flags); - nano::genesis genesis; nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node.work_generate_blocking (genesis.hash ())) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); auto send2 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) .build_shared (); auto send3 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send2->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 3 * nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 3 * nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send2->hash ())) .build_shared (); // The write guard prevents block processor doing any writes @@ -3522,14 +3509,13 @@ TEST (node, confirm_back) nano::system system (1); nano::keypair key; auto & node (*system.nodes[0]); - nano::genesis genesis; - auto genesis_start_balance (node.balance (nano::dev_genesis_key.pub)); + auto genesis_start_balance (node.balance (nano::dev::genesis_key.pub)); auto send1 = nano::send_block_builder () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key.pub) .balance (genesis_start_balance - 1) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); nano::state_block_builder builder; auto open = builder.make_block () @@ -3546,7 +3532,7 @@ TEST (node, confirm_back) .previous (open->hash ()) .representative (key.pub) .balance (0) - .link (nano::dev_genesis_key.pub) + .link (nano::dev::genesis_key.pub) .sign (key.prv, key.pub) .work (*system.work.generate (open->hash ())) .build_shared (); @@ -3557,7 +3543,7 @@ TEST (node, confirm_back) ASSERT_EQ (3, node.active.size ()); std::vector vote_blocks; vote_blocks.push_back (send2->hash ()); - auto vote (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), vote_blocks)); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, vote_blocks)); node.vote_processor.vote_blocking (vote, std::make_shared (node)); ASSERT_TIMELY (10s, node.active.empty ()); } @@ -3577,10 +3563,10 @@ TEST (node, peers) { // Add a peer to the database auto transaction (store.tx_begin_write ()); - store.peer_put (transaction, endpoint_key); + store.peer.put (transaction, endpoint_key); // Add a peer which is not contactable - store.peer_put (transaction, nano::endpoint_key{ boost::asio::ip::address_v6::any ().to_bytes (), 55555 }); + store.peer.put (transaction, nano::endpoint_key{ boost::asio::ip::address_v6::any ().to_bytes (), 55555 }); } node2->start (); @@ -3605,8 +3591,8 @@ TEST (node, peers) // Uncontactable peer should not be stored auto transaction (store.tx_begin_read ()); - ASSERT_EQ (store.peer_count (transaction), 1); - ASSERT_TRUE (store.peer_exists (transaction, endpoint_key)); + ASSERT_EQ (store.peer.count (transaction), 1); + ASSERT_TRUE (store.peer.exists (transaction, endpoint_key)); node2->stop (); } @@ -3626,7 +3612,7 @@ TEST (node, peer_cache_restart) { // Add a peer to the database auto transaction (store.tx_begin_write ()); - store.peer_put (transaction, endpoint_key); + store.peer.put (transaction, endpoint_key); } node2->start (); ASSERT_TIMELY (10s, !node2->network.empty ()); @@ -3649,8 +3635,8 @@ TEST (node, peer_cache_restart) auto & store = node3->store; { auto transaction (store.tx_begin_read ()); - ASSERT_EQ (store.peer_count (transaction), 1); - ASSERT_TRUE (store.peer_exists (transaction, endpoint_key)); + ASSERT_EQ (store.peer.count (transaction), 1); + ASSERT_TRUE (store.peer.exists (transaction, endpoint_key)); } ASSERT_TIMELY (10s, !node3->network.empty ()); // Confirm that the peers match with the endpoints we are expecting @@ -3690,27 +3676,27 @@ TEST (node, unchecked_cleanup) node.config.unchecked_cutoff_time = std::chrono::seconds (2); { auto transaction (node.store.tx_begin_read ()); - auto unchecked_count (node.store.unchecked_count (transaction)); + auto unchecked_count (node.store.unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 1); - ASSERT_EQ (unchecked_count, node.store.unchecked_count (transaction)); + ASSERT_EQ (unchecked_count, node.store.unchecked.count (transaction)); } std::this_thread::sleep_for (std::chrono::seconds (1)); node.unchecked_cleanup (); ASSERT_TRUE (node.network.publish_filter.apply (bytes.data (), bytes.size ())); { auto transaction (node.store.tx_begin_read ()); - auto unchecked_count (node.store.unchecked_count (transaction)); + auto unchecked_count (node.store.unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 1); - ASSERT_EQ (unchecked_count, node.store.unchecked_count (transaction)); + ASSERT_EQ (unchecked_count, node.store.unchecked.count (transaction)); } std::this_thread::sleep_for (std::chrono::seconds (2)); node.unchecked_cleanup (); ASSERT_FALSE (node.network.publish_filter.apply (bytes.data (), bytes.size ())); { auto transaction (node.store.tx_begin_read ()); - auto unchecked_count (node.store.unchecked_count (transaction)); + auto unchecked_count (node.store.unchecked.count (transaction)); ASSERT_EQ (unchecked_count, 0); - ASSERT_EQ (unchecked_count, node.store.unchecked_count (transaction)); + ASSERT_EQ (unchecked_count, node.store.unchecked.count (transaction)); } } @@ -3723,12 +3709,11 @@ TEST (node, dont_write_lock_node) std::promise finished_promise; std::thread ([&path, &write_lock_held_promise, &finished_promise] () { nano::logger_mt logger; - auto store = nano::make_store (logger, path, false, true); + auto store = nano::make_store (logger, path, nano::dev::constants, false, true); { - nano::genesis genesis; nano::ledger_cache ledger_cache; auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger_cache); + store->initialize (transaction, ledger_cache); } // Hold write lock open until main thread is done needing it @@ -3748,7 +3733,7 @@ TEST (node, dont_write_lock_node) TEST (node, bidirectional_tcp) { #ifdef _WIN32 - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; @@ -3778,23 +3763,22 @@ TEST (node, bidirectional_tcp) ASSERT_EQ (node1->network.endpoint (), list2[0]->get_endpoint ()); ASSERT_EQ (node1->node_id.pub, list2[0]->get_node_id ()); // Test block propagation from node 1 - nano::genesis genesis; nano::keypair key; nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node1->work_generate_blocking (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1->work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); node1->process_active (send1); node1->block_processor.flush (); ASSERT_TIMELY (10s, node1->ledger.block_or_pruned_exists (send1->hash ()) && node2->ledger.block_or_pruned_exists (send1->hash ())); // Test block confirmation from node 1 (add representative to node 1) - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // Wait to find new reresentative ASSERT_TIMELY (10s, node2->rep_crawler.representative_count () != 0); /* Wait for confirmation @@ -3811,24 +3795,24 @@ TEST (node, bidirectional_tcp) // Test block propagation & confirmation from node 2 (remove representative from node 1) { auto transaction (system.wallet (0)->wallets.tx_begin_write ()); - system.wallet (0)->store.erase (transaction, nano::dev_genesis_key.pub); + system.wallet (0)->store.erase (transaction, nano::dev::genesis_key.pub); } /* Test block propagation from node 2 Node 2 has only ephemeral TCP port open. Node 1 cannot establish connection to node 2 listening port */ auto send2 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node1->work_generate_blocking (send1->hash ())) .build_shared (); node2->process_active (send2); node2->block_processor.flush (); ASSERT_TIMELY (10s, node1->ledger.block_or_pruned_exists (send2->hash ()) && node2->ledger.block_or_pruned_exists (send2->hash ())); // Test block confirmation from node 2 (add representative to node 2) - system.wallet (1)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); // Wait to find changed reresentative ASSERT_TIMELY (10s, node1->rep_crawler.representative_count () != 0); /* Wait for confirmation @@ -3860,7 +3844,7 @@ TEST (node, aggressive_flooding) node_flags.disable_wallet_bootstrap = true; auto & node1 (*system.add_node (node_flags)); auto & wallet1 (*system.wallet (0)); - wallet1.insert_adhoc (nano::dev_genesis_key.prv); + wallet1.insert_adhoc (nano::dev::genesis_key.prv); std::vector, std::shared_ptr>> nodes_wallets; bool const sanitizer_or_valgrind (is_sanitizer_build || nano::running_within_valgrind ()); nodes_wallets.resize (!sanitizer_or_valgrind ? 5 : 3); @@ -3879,14 +3863,14 @@ TEST (node, aggressive_flooding) ASSERT_TIMELY (10s, std::all_of (nodes_wallets.begin (), nodes_wallets.end (), [] (auto const & node_wallet) { return node_wallet.first->rep_crawler.principal_representatives ().size () != 0; })); // Send a large amount to create a principal representative in each node - auto large_amount = (nano::genesis_amount / 2) / nodes_wallets.size (); + auto large_amount = (nano::dev::constants.genesis_amount / 2) / nodes_wallets.size (); std::vector> genesis_blocks; for (auto & node_wallet : nodes_wallets) { nano::keypair keypair; node_wallet.second->store.representative_set (node_wallet.first->wallets.tx_begin_write (), keypair.pub); node_wallet.second->insert_adhoc (keypair.prv); - auto block (wallet1.send_action (nano::dev_genesis_key.pub, keypair.pub, large_amount)); + auto block (wallet1.send_action (nano::dev::genesis_key.pub, keypair.pub, large_amount)); ASSERT_NE (nullptr, block); genesis_blocks.push_back (block); } @@ -3899,8 +3883,8 @@ TEST (node, aggressive_flooding) auto process_result (node_wallet.first->process (*block)); ASSERT_TRUE (nano::process_result::progress == process_result.code || nano::process_result::old == process_result.code); } - ASSERT_EQ (node1.latest (nano::dev_genesis_key.pub), node_wallet.first->latest (nano::dev_genesis_key.pub)); - ASSERT_EQ (genesis_blocks.back ()->hash (), node_wallet.first->latest (nano::dev_genesis_key.pub)); + ASSERT_EQ (node1.latest (nano::dev::genesis_key.pub), node_wallet.first->latest (nano::dev::genesis_key.pub)); + ASSERT_EQ (genesis_blocks.back ()->hash (), node_wallet.first->latest (nano::dev::genesis_key.pub)); // Confirm blocks for rep crawler & receiving nano::blocks_confirm (*node_wallet.first, { genesis_blocks.back () }, true); } @@ -3927,13 +3911,13 @@ TEST (node, aggressive_flooding) { auto transaction (node1.store.tx_begin_read ()); block = builder.make_block () - .account (nano::dev_genesis_key.pub) - .representative (nano::dev_genesis_key.pub) - .previous (node1.ledger.latest (transaction, nano::dev_genesis_key.pub)) - .balance (node1.ledger.account_balance (transaction, nano::dev_genesis_key.pub) - 1) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node1.work_generate_blocking (node1.ledger.latest (transaction, nano::dev_genesis_key.pub))) + .account (nano::dev::genesis_key.pub) + .representative (nano::dev::genesis_key.pub) + .previous (node1.ledger.latest (transaction, nano::dev::genesis_key.pub)) + .balance (node1.ledger.account_balance (transaction, nano::dev::genesis_key.pub) - 1) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node1.work_generate_blocking (node1.ledger.latest (transaction, nano::dev::genesis_key.pub))) .build (); } // Processing locally goes through the aggressive block flooding path @@ -3948,7 +3932,7 @@ TEST (node, aggressive_flooding) ASSERT_TIMELY (!sanitizer_or_valgrind ? 5s : 25s, all_have_block (block->hash ())); // Do the same for a wallet block - auto wallet_block = wallet1.send_sync (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, 10); + auto wallet_block = wallet1.send_sync (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 10); ASSERT_TIMELY (!sanitizer_or_valgrind ? 5s : 25s, all_have_block (wallet_block)); // All blocks: genesis + (send+open) for each representative + 2 local blocks @@ -3975,13 +3959,13 @@ TEST (node, rollback_vote_self) nano::keypair key; auto weight = node.online_reps.delta (); auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .link (key.pub) - .balance (nano::genesis_amount - weight) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .balance (nano::dev::constants.genesis_amount - weight) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto open = builder.make_block () .account (key.pub) @@ -3996,14 +3980,14 @@ TEST (node, rollback_vote_self) .from (*send1) .previous (send1->hash ()) .balance (send1->balance ().number () - 1) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); auto fork = builder.make_block () .from (*send2) .balance (send2->balance ().number () - 2) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.process (*send1).code); ASSERT_EQ (nano::process_result::progress, node.process (*open).code); @@ -4024,7 +4008,7 @@ TEST (node, rollback_vote_self) ASSERT_NE (nullptr, election); ASSERT_EQ (2, election->blocks ().size ()); // Insert genesis key in the wallet - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); { // The write guard prevents the block processor from performing the rollback auto write_guard = node.write_database_queue.wait (nano::writer::testing); @@ -4050,7 +4034,7 @@ TEST (node, rollback_vote_self) // A vote is eventually generated from the local representative ASSERT_TIMELY (5s, 3 == election->votes ().size ()); auto votes (election->votes ()); - auto vote (votes.find (nano::dev_genesis_key.pub)); + auto vote (votes.find (nano::dev::genesis_key.pub)); ASSERT_NE (votes.end (), vote); ASSERT_EQ (fork->hash (), vote->second.hash); } @@ -4064,13 +4048,13 @@ TEST (node, rollback_gap_source) nano::state_block_builder builder; nano::keypair key; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .link (key.pub) - .balance (nano::genesis_amount - 1) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .balance (nano::dev::constants.genesis_amount - 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto fork = builder.make_block () .account (key.pub) @@ -4086,7 +4070,7 @@ TEST (node, rollback_gap_source) .previous (send1->hash ()) .balance (send1->balance ().number () - 1) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); auto open = builder.make_block () @@ -4109,7 +4093,7 @@ TEST (node, rollback_gap_source) ASSERT_EQ (2, election->blocks ().size ()); ASSERT_EQ (1, election->votes ().size ()); // Confirm open - auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), std::vector (1, open->hash ()))); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector (1, open->hash ()))); node.vote_processor.vote (vote1, std::make_shared (node)); ASSERT_TIMELY (5s, election->votes ().size () == 2); ASSERT_TIMELY (3s, election->confirmed ()); @@ -4136,7 +4120,7 @@ TEST (node, rollback_gap_source) node.block_processor.flush (); ASSERT_EQ (2, election->blocks ().size ()); // Confirm open (again) - auto vote1 (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, std::numeric_limits::max (), std::vector (1, open->hash ()))); + auto vote1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_max, nano::vote::duration_max, std::vector (1, open->hash ()))); node.vote_processor.vote (vote1, std::make_shared (node)); ASSERT_TIMELY (5s, election->votes ().size () == 2); } @@ -4161,13 +4145,13 @@ TEST (node, dependency_graph) // Send to key1 auto gen_send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .link (key1.pub) - .balance (nano::genesis_amount - 1) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .balance (nano::dev::constants.genesis_amount - 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); // Receive from genesis auto key1_open = builder.make_block () @@ -4184,7 +4168,7 @@ TEST (node, dependency_graph) .account (key1.pub) .previous (key1_open->hash ()) .representative (key1.pub) - .link (nano::dev_genesis_key.pub) + .link (nano::dev::genesis_key.pub) .balance (0) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_open->hash ())) @@ -4194,8 +4178,8 @@ TEST (node, dependency_graph) .from (*gen_send1) .previous (gen_send1->hash ()) .link (key1_send1->hash ()) - .balance (nano::genesis_amount) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (gen_send1->hash ())) .build (); // Send to key2 @@ -4204,7 +4188,7 @@ TEST (node, dependency_graph) .previous (gen_receive->hash ()) .link (key2.pub) .balance (gen_receive->balance ().number () - 2) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (gen_receive->hash ())) .build (); // Receive from genesis @@ -4279,7 +4263,7 @@ TEST (node, dependency_graph) .previous (key3_receive->hash ()) .link (node.ledger.epoch_link (nano::epoch::epoch_1)) .balance (key3_receive->balance ()) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (key3_receive->hash ())) .build (); @@ -4316,7 +4300,7 @@ TEST (node, dependency_graph) ASSERT_EQ (node.ledger.cache.block_count - 2, dependency_graph.size ()); // Start an election for the first block of the dependency graph, and ensure all blocks are eventually confirmed - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); node.block_confirm (gen_send1); ASSERT_NO_ERROR (system.poll_until_true (15s, [&] { @@ -4363,13 +4347,13 @@ TEST (node, dependency_graph_frontier) // Send to key1 auto gen_send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .link (key1.pub) - .balance (nano::genesis_amount - 1) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .balance (nano::dev::constants.genesis_amount - 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); // Receive from genesis auto key1_open = builder.make_block () @@ -4386,7 +4370,7 @@ TEST (node, dependency_graph_frontier) .account (key1.pub) .previous (key1_open->hash ()) .representative (key1.pub) - .link (nano::dev_genesis_key.pub) + .link (nano::dev::genesis_key.pub) .balance (0) .sign (key1.prv, key1.pub) .work (*system.work.generate (key1_open->hash ())) @@ -4396,8 +4380,8 @@ TEST (node, dependency_graph_frontier) .from (*gen_send1) .previous (gen_send1->hash ()) .link (key1_send1->hash ()) - .balance (nano::genesis_amount) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (gen_send1->hash ())) .build (); // Send to key2 @@ -4406,7 +4390,7 @@ TEST (node, dependency_graph_frontier) .previous (gen_receive->hash ()) .link (key2.pub) .balance (gen_receive->balance ().number () - 2) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (gen_receive->hash ())) .build (); // Receive from genesis @@ -4481,7 +4465,7 @@ TEST (node, dependency_graph_frontier) .previous (key3_receive->hash ()) .link (node1.ledger.epoch_link (nano::epoch::epoch_1)) .balance (key3_receive->balance ()) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (key3_receive->hash ())) .build (); @@ -4504,7 +4488,7 @@ TEST (node, dependency_graph_frontier) } // node1 can vote, but only on the first block - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_TIMELY (10s, node2.active.active (gen_send1->qualified_root ())); node1.block_confirm (gen_send1); @@ -4526,13 +4510,13 @@ TEST (node, deferred_dependent_elections) nano::state_block_builder builder; nano::keypair key; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) .link (key.pub) - .balance (nano::genesis_amount - 1) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .balance (nano::dev::constants.genesis_amount - 1) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto open = builder.make_block () .account (key.pub) @@ -4548,7 +4532,7 @@ TEST (node, deferred_dependent_elections) .previous (send1->hash ()) .balance (send1->balance ().number () - 1) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); auto receive = builder.make_block () @@ -4561,7 +4545,7 @@ TEST (node, deferred_dependent_elections) .build_shared (); auto fork = builder.make_block () .from (*receive) - .representative (nano::dev_genesis_key.pub) // was key.pub + .representative (nano::dev::genesis_key.pub) // was key.pub .sign (key.prv, key.pub) .build_shared (); node.process_local (send1); @@ -4574,6 +4558,7 @@ TEST (node, deferred_dependent_elections) node.process_local (open); node.process_local (send2); node.block_processor.flush (); + node.scheduler.flush (); ASSERT_TRUE (node.block (open->hash ())); ASSERT_TRUE (node.block (send2->hash ())); ASSERT_FALSE (node.active.active (open->qualified_root ())); @@ -4582,12 +4567,11 @@ TEST (node, deferred_dependent_elections) ASSERT_TIMELY (2s, node2.block (send2->hash ())); // Re-processing older blocks with updated work also does not start an election - node.work_generate_blocking (*open, open->difficulty () + 1); + node.work_generate_blocking (*open, nano::dev::network_params.work.difficulty (*open) + 1); node.process_local (open); node.block_processor.flush (); + node.scheduler.flush (); ASSERT_FALSE (node.active.active (open->qualified_root ())); - /// However, work is still updated - ASSERT_TIMELY (3s, node.store.block_get (node.store.tx_begin_read (), open->hash ())->block_work () == open->block_work ()); // It is however possible to manually start an election from elsewhere node.block_confirm (open); @@ -4596,13 +4580,12 @@ TEST (node, deferred_dependent_elections) ASSERT_FALSE (node.active.active (open->qualified_root ())); /// The election was dropped but it's still not possible to restart it - node.work_generate_blocking (*open, open->difficulty () + 1); + node.work_generate_blocking (*open, nano::dev::network_params.work.difficulty (*open) + 1); ASSERT_FALSE (node.active.active (open->qualified_root ())); node.process_local (open); node.block_processor.flush (); + node.scheduler.flush (); ASSERT_FALSE (node.active.active (open->qualified_root ())); - /// However, work is still updated - ASSERT_TIMELY (3s, node.store.block_get (node.store.tx_begin_read (), open->hash ())->block_work () == open->block_work ()); // Frontier confirmation also starts elections ASSERT_NO_ERROR (system.poll_until_true (5s, [&node, &send2] { @@ -4639,6 +4622,7 @@ TEST (node, deferred_dependent_elections) ASSERT_FALSE (node.block (receive->hash ())); node.process_local (receive); node.block_processor.flush (); + node.scheduler.flush (); ASSERT_TRUE (node.block (receive->hash ())); ASSERT_FALSE (node.active.active (receive->qualified_root ())); @@ -4646,18 +4630,13 @@ TEST (node, deferred_dependent_elections) ASSERT_EQ (nano::process_result::fork, node.process (*fork).code); node.process_local (fork); node.block_processor.flush (); + node.scheduler.flush (); ASSERT_FALSE (node.active.active (receive->qualified_root ())); // Confirming the other dependency allows starting an election from a fork election_send2->force_confirm (); ASSERT_TIMELY (2s, node.block_confirmed (send2->hash ())); ASSERT_TIMELY (2s, node.active.active (receive->qualified_root ())); - node.active.erase (*receive); - ASSERT_FALSE (node.active.active (receive->qualified_root ())); - node.work_generate_blocking (*receive, receive->difficulty () + 1); - node.process_local (receive); - node.block_processor.flush (); - ASSERT_TRUE (node.active.active (receive->qualified_root ())); } } @@ -4666,10 +4645,10 @@ TEST (rep_crawler, recently_confirmed) nano::system system (1); auto & node1 (*system.nodes[0]); ASSERT_EQ (1, node1.ledger.cache.block_count); - auto const block = nano::genesis ().open; + auto const block = nano::dev::genesis; node1.active.add_recently_confirmed (block->qualified_root (), block->hash ()); auto & node2 (*system.add_node ()); - system.wallet (1)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (1)->insert_adhoc (nano::dev::genesis_key.prv); auto channel = node1.network.find_channel (node2.network.endpoint ()); ASSERT_NE (nullptr, channel); node1.rep_crawler.query (channel); @@ -4685,10 +4664,10 @@ TEST (rep_crawler, local) flags.disable_rep_crawler = true; auto & node = *system.add_node (flags); auto loopback = std::make_shared (node); - auto vote = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, std::vector{ nano::genesis_hash }); + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, std::vector{ nano::dev::genesis->hash () }); { nano::lock_guard guard (node.rep_crawler.probable_reps_mutex); - node.rep_crawler.active.insert (nano::genesis_hash); + node.rep_crawler.active.insert (nano::dev::genesis->hash ()); node.rep_crawler.responses.emplace_back (loopback, vote); } node.rep_crawler.validate (); @@ -4705,20 +4684,19 @@ TEST (node, pruning_automatic) nano::node_flags node_flags; node_flags.enable_pruning = true; auto & node1 = *system.add_node (node_config, node_flags); - nano::genesis genesis; nano::keypair key1; auto send1 = nano::send_block_builder () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key1.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto send2 = nano::send_block_builder () .previous (send1->hash ()) .destination (key1.pub) .balance (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); // Process as local blocks @@ -4742,10 +4720,10 @@ TEST (node, pruning_automatic) ASSERT_TIMELY (2s, node1.active.empty () && node1.block_confirmed (send2->hash ())); // Check pruning result ASSERT_TIMELY (3s, node1.ledger.cache.pruned_count == 1); - ASSERT_TIMELY (2s, node1.store.pruned_count (node1.store.tx_begin_read ()) == 1); // Transaction commit + ASSERT_TIMELY (2s, node1.store.pruned.count (node1.store.tx_begin_read ()) == 1); // Transaction commit ASSERT_EQ (1, node1.ledger.cache.pruned_count); ASSERT_EQ (3, node1.ledger.cache.block_count); - ASSERT_TRUE (node1.ledger.block_or_pruned_exists (genesis.hash ())); + ASSERT_TRUE (node1.ledger.block_or_pruned_exists (nano::dev::genesis->hash ())); ASSERT_TRUE (node1.ledger.block_or_pruned_exists (send1->hash ())); // true for pruned ASSERT_TRUE (node1.ledger.block_or_pruned_exists (send2->hash ())); } @@ -4758,20 +4736,19 @@ TEST (node, pruning_age) nano::node_flags node_flags; node_flags.enable_pruning = true; auto & node1 = *system.add_node (node_config, node_flags); - nano::genesis genesis; nano::keypair key1; auto send1 = nano::send_block_builder () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key1.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto send2 = nano::send_block_builder () .previous (send1->hash ()) .destination (key1.pub) .balance (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); // Process as local blocks @@ -4802,7 +4779,7 @@ TEST (node, pruning_age) node1.ledger_pruning (1, true, false); ASSERT_EQ (1, node1.ledger.cache.pruned_count); ASSERT_EQ (3, node1.ledger.cache.block_count); - ASSERT_TRUE (node1.ledger.block_or_pruned_exists (genesis.hash ())); + ASSERT_TRUE (node1.ledger.block_or_pruned_exists (nano::dev::genesis->hash ())); ASSERT_TRUE (node1.ledger.block_or_pruned_exists (send1->hash ())); // true for pruned ASSERT_TRUE (node1.ledger.block_or_pruned_exists (send2->hash ())); } @@ -4815,20 +4792,19 @@ TEST (node, pruning_depth) nano::node_flags node_flags; node_flags.enable_pruning = true; auto & node1 = *system.add_node (node_config, node_flags); - nano::genesis genesis; nano::keypair key1; auto send1 = nano::send_block_builder () - .previous (genesis.hash ()) + .previous (nano::dev::genesis->hash ()) .destination (key1.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto send2 = nano::send_block_builder () .previous (send1->hash ()) .destination (key1.pub) .balance (0) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); // Process as local blocks @@ -4855,7 +4831,7 @@ TEST (node, pruning_depth) node1.ledger_pruning (1, true, false); ASSERT_EQ (1, node1.ledger.cache.pruned_count); ASSERT_EQ (3, node1.ledger.cache.block_count); - ASSERT_TRUE (node1.ledger.block_or_pruned_exists (genesis.hash ())); + ASSERT_TRUE (node1.ledger.block_or_pruned_exists (nano::dev::genesis->hash ())); ASSERT_TRUE (node1.ledger.block_or_pruned_exists (send1->hash ())); // true for pruned ASSERT_TRUE (node1.ledger.block_or_pruned_exists (send2->hash ())); } diff --git a/nano/core_test/peer_container.cpp b/nano/core_test/peer_container.cpp index 9914ab3e9a..2ae9a3c58a 100644 --- a/nano/core_test/peer_container.cpp +++ b/nano/core_test/peer_container.cpp @@ -1,4 +1,4 @@ -#include +#include #include #include @@ -22,9 +22,9 @@ TEST (peer_container, no_recontact) ASSERT_EQ (0, network.size ()); network.channel_observer = [&observed_peer] (std::shared_ptr const &) { ++observed_peer; }; node1.network.disconnect_observer = [&observed_disconnect] () { observed_disconnect = true; }; - auto channel (network.udp_channels.insert (endpoint1, node1.network_params.protocol.protocol_version)); + auto channel (network.udp_channels.insert (endpoint1, node1.network_params.network.protocol_version)); ASSERT_EQ (1, network.size ()); - ASSERT_EQ (channel, network.udp_channels.insert (endpoint1, node1.network_params.protocol.protocol_version)); + ASSERT_EQ (channel, network.udp_channels.insert (endpoint1, node1.network_params.network.protocol_version)); node1.network.cleanup (std::chrono::steady_clock::now () + std::chrono::seconds (5)); ASSERT_TRUE (network.empty ()); ASSERT_EQ (1, observed_peer); @@ -125,8 +125,8 @@ TEST (peer_container, list_fanout) ASSERT_EQ (0, node.network.fanout ()); auto list1 (node.network.list (node.network.fanout ())); ASSERT_TRUE (list1.empty ()); - auto add_peer = [&node] (const uint16_t port_a) { - ASSERT_NE (nullptr, node.network.udp_channels.insert (nano::endpoint (boost::asio::ip::address_v6::loopback (), port_a), node.network_params.protocol.protocol_version)); + auto add_peer = [&node] (uint16_t const port_a) { + ASSERT_NE (nullptr, node.network.udp_channels.insert (nano::endpoint (boost::asio::ip::address_v6::loopback (), port_a), node.network_params.network.protocol_version)); }; add_peer (9998); ASSERT_EQ (1, node.network.size ()); @@ -161,7 +161,7 @@ TEST (peer_container, reachout) auto & node1 = *system.add_node (node_flags); nano::endpoint endpoint0 (boost::asio::ip::address_v6::loopback (), nano::get_available_port ()); // Make sure having been contacted by them already indicates we shouldn't reach out - node1.network.udp_channels.insert (endpoint0, node1.network_params.protocol.protocol_version); + node1.network.udp_channels.insert (endpoint0, node1.network_params.network.protocol_version); ASSERT_TRUE (node1.network.reachout (endpoint0)); nano::endpoint endpoint1 (boost::asio::ip::address_v6::loopback (), nano::get_available_port ()); ASSERT_FALSE (node1.network.reachout (endpoint1)); @@ -179,8 +179,8 @@ TEST (peer_container, depeer) { nano::system system (1); nano::endpoint endpoint0 (boost::asio::ip::address_v6::loopback (), nano::get_available_port ()); - nano::keepalive message; - message.header.version_using = 1; + nano::keepalive message{ nano::dev::network_params.network }; + const_cast (message.header.version_using) = 1; auto bytes (message.to_bytes ()); nano::message_buffer buffer = { bytes->data (), bytes->size (), endpoint0 }; system.nodes[0]->network.udp_channels.receive_action (&buffer); diff --git a/nano/core_test/processor_service.cpp b/nano/core_test/processor_service.cpp index 913eba5b03..1cf5bf49b4 100644 --- a/nano/core_test/processor_service.cpp +++ b/nano/core_test/processor_service.cpp @@ -1,7 +1,7 @@ #include #include -#include #include +#include #include #include @@ -10,18 +10,17 @@ TEST (processor_service, bad_send_signature) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::account_info info1; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info1)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1)); nano::keypair key2; - nano::send_block send (info1.head, nano::dev_genesis_key.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head)); + nano::send_block send (info1.head, nano::dev::genesis_key.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head)); send.signature.bytes[32] ^= 0x1; ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, send).code); } @@ -29,22 +28,21 @@ TEST (processor_service, bad_send_signature) TEST (processor_service, bad_receive_signature) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::account_info info1; - ASSERT_FALSE (store->account_get (transaction, nano::dev_genesis_key.pub, info1)); - nano::send_block send (info1.head, nano::dev_genesis_key.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (info1.head)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info1)); + nano::send_block send (info1.head, nano::dev::genesis_key.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (info1.head)); 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::dev_genesis_key.pub, info2)); - nano::receive_block receive (hash1, hash1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (hash1)); + ASSERT_FALSE (store->account.get (transaction, nano::dev::genesis_key.pub, info2)); + nano::receive_block receive (hash1, hash1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (hash1)); receive.signature.bytes[32] ^= 0x1; ASSERT_EQ (nano::process_result::bad_signature, ledger.process (transaction, receive).code); } diff --git a/nano/core_test/request_aggregator.cpp b/nano/core_test/request_aggregator.cpp index 26e9669899..e10462ad25 100644 --- a/nano/core_test/request_aggregator.cpp +++ b/nano/core_test/request_aggregator.cpp @@ -1,6 +1,6 @@ #include #include -#include +#include #include #include @@ -13,9 +13,8 @@ TEST (request_aggregator, one) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node (*system.add_node (node_config)); - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto send1 (std::make_shared (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node.work_generate_blocking (genesis.hash ()))); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto send1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ()))); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); auto channel (node.network.udp_channels.create (node.network.endpoint ())); @@ -49,36 +48,35 @@ TEST (request_aggregator, one_update) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node (*system.add_node (node_config)); - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key1; auto send1 = nano::state_block_builder () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node.work_generate_blocking (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); node.confirmation_height_processor.add (send1); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); auto send2 = nano::state_block_builder () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code); auto receive1 = nano::state_block_builder () .account (key1.pub) .previous (0) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (nano::MBAN_ratio) .link (send1->hash ()) .sign (key1.prv, key1.pub) @@ -115,35 +113,34 @@ TEST (request_aggregator, two) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node (*system.add_node (node_config)); - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key1; nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 1) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 1) .link (key1.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node.work_generate_blocking (genesis.hash ())) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node.work_generate_blocking (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); node.confirmation_height_processor.add (send1); ASSERT_TIMELY (5s, node.ledger.block_confirmed (node.store.tx_begin_read (), send1->hash ())); auto send2 = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (send1->hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*node.work_generate_blocking (send1->hash ())) .build_shared (); auto receive1 = builder.make_block () .account (key1.pub) .previous (0) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (1) .link (send1->hash ()) .sign (key1.prv, key1.pub) @@ -192,9 +189,8 @@ TEST (request_aggregator, two_endpoints) auto & node1 (*system.add_node (node_config, node_flags)); node_config.peering_port = nano::get_available_port (); auto & node2 (*system.add_node (node_config, node_flags)); - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto send1 (std::make_shared (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 1, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (genesis.hash ()))); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto send1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 1, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1.work_generate_blocking (nano::dev::genesis->hash ()))); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); ASSERT_EQ (nano::process_result::progress, node1.ledger.process (node1.store.tx_begin_write (), *send1).code); @@ -224,23 +220,22 @@ TEST (request_aggregator, split) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node (*system.add_node (node_config)); - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); std::vector> request; std::vector> blocks; - auto previous = genesis.hash (); + auto previous = nano::dev::genesis->hash (); // Add max_vbh + 1 blocks and request votes for them for (size_t i (0); i <= max_vbh; ++i) { nano::block_builder builder; blocks.push_back (builder .state () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (previous) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - (i + 1)) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - (i + 1)) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) .build ()); auto const & block = blocks.back (); @@ -278,9 +273,8 @@ TEST (request_aggregator, channel_lifetime) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node (*system.add_node (node_config)); - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto send1 (std::make_shared (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node.work_generate_blocking (genesis.hash ()))); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto send1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ()))); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); @@ -299,9 +293,8 @@ TEST (request_aggregator, channel_update) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node (*system.add_node (node_config)); - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto send1 (std::make_shared (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node.work_generate_blocking (genesis.hash ()))); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto send1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ()))); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); @@ -328,9 +321,8 @@ TEST (request_aggregator, channel_max_queue) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; node_config.max_queued_requests = 1; auto & node (*system.add_node (node_config)); - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto send1 (std::make_shared (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node.work_generate_blocking (genesis.hash ()))); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto send1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ()))); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); @@ -346,9 +338,8 @@ TEST (request_aggregator, unique) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto & node (*system.add_node (node_config)); - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto send1 (std::make_shared (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node.work_generate_blocking (genesis.hash ()))); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto send1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node.work_generate_blocking (nano::dev::genesis->hash ()))); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); std::vector> request; request.emplace_back (send1->hash (), send1->root ()); @@ -371,27 +362,26 @@ TEST (request_aggregator, cannot_vote) auto & node (*system.add_node (flags)); // This prevents activation of blocks which are cemented node.confirmation_height_processor.cemented_observers.clear (); - nano::genesis genesis; nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 1) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 1) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto send2 = builder.make_block () .from (*send1) .previous (send1->hash ()) .balance (send1->balance ().number () - 1) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (send1->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.process (*send1).code); ASSERT_EQ (nano::process_result::progress, node.process (*send2).code); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_FALSE (node.ledger.dependents_confirmed (node.store.tx_begin_read (), *send2)); std::vector> request; diff --git a/nano/core_test/socket.cpp b/nano/core_test/socket.cpp index eedab3997c..23c0043a75 100644 --- a/nano/core_test/socket.cpp +++ b/nano/core_test/socket.cpp @@ -1,12 +1,413 @@ +#include +#include #include #include -#include +#include #include #include +#include +#include +#include +#include + using namespace std::chrono_literals; +TEST (socket, max_connections) +{ + nano::system system; + + auto node = system.add_node (); + + auto server_port = nano::get_available_port (); + boost::asio::ip::tcp::endpoint listen_endpoint{ boost::asio::ip::address_v6::any (), server_port }; + boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), server_port }; + + // start a server socket that allows max 2 live connections + auto server_socket = std::make_shared (*node, listen_endpoint, 2); + boost::system::error_code ec; + server_socket->start (ec); + ASSERT_FALSE (ec); + + // successful incoming connections are stored in server_sockets to keep them alive (server side) + std::vector> server_sockets; + server_socket->on_connection ([&server_sockets] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { + server_sockets.push_back (new_connection); + return true; + }); + + // client side connection tracking + std::atomic connection_attempts = 0; + auto connect_handler = [&connection_attempts] (boost::system::error_code const & ec_a) { + ASSERT_EQ (ec_a.value (), 0); + ++connection_attempts; + }; + + // start 3 clients, 2 will persist but 1 will be dropped + + auto client1 = std::make_shared (*node); + client1->async_connect (dst_endpoint, connect_handler); + + auto client2 = std::make_shared (*node); + client2->async_connect (dst_endpoint, connect_handler); + + auto client3 = std::make_shared (*node); + client3->async_connect (dst_endpoint, connect_handler); + + auto get_tcp_accept_failures = [&node] () { + return node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_accept_failure, nano::stat::dir::in); + }; + + auto get_tcp_accept_successes = [&node] () { + return node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_accept_success, nano::stat::dir::in); + }; + + ASSERT_TIMELY (5s, get_tcp_accept_failures () == 1); + ASSERT_TIMELY (5s, get_tcp_accept_successes () == 2); + ASSERT_TIMELY (5s, connection_attempts == 3); + + // create space for one socket and fill the connections table again + + server_sockets[0].reset (); + + auto client4 = std::make_shared (*node); + client4->async_connect (dst_endpoint, connect_handler); + + auto client5 = std::make_shared (*node); + client5->async_connect (dst_endpoint, connect_handler); + + ASSERT_TIMELY (5s, get_tcp_accept_failures () == 2); + ASSERT_TIMELY (5s, get_tcp_accept_successes () == 3); + ASSERT_TIMELY (5s, connection_attempts == 5); + + // close all existing sockets and fill the connections table again + // start counting form 1 because 0 is the already closed socket + + server_sockets[1].reset (); + server_sockets[2].reset (); + ASSERT_EQ (server_sockets.size (), 3); + + auto client6 = std::make_shared (*node); + client6->async_connect (dst_endpoint, connect_handler); + + auto client7 = std::make_shared (*node); + client7->async_connect (dst_endpoint, connect_handler); + + auto client8 = std::make_shared (*node); + client8->async_connect (dst_endpoint, connect_handler); + + ASSERT_TIMELY (5s, get_tcp_accept_failures () == 3); + ASSERT_TIMELY (5s, get_tcp_accept_successes () == 5); + ASSERT_TIMELY (5s, connection_attempts == 8); // connections initiated by the client + ASSERT_TIMELY (5s, server_sockets.size () == 5); // connections accepted by the server + + node->stop (); +} + +TEST (socket, max_connections_per_ip) +{ + nano::system system; + + auto node = system.add_node (); + ASSERT_FALSE (node->flags.disable_max_peers_per_ip); + + auto server_port = nano::get_available_port (); + boost::asio::ip::tcp::endpoint listen_endpoint{ boost::asio::ip::address_v6::any (), server_port }; + boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), server_port }; + + const auto max_ip_connections = node->network_params.network.max_peers_per_ip; + ASSERT_TRUE (max_ip_connections >= 1); + + const auto max_global_connections = 1000; + + auto server_socket = std::make_shared (*node, listen_endpoint, max_global_connections); + boost::system::error_code ec; + server_socket->start (ec); + ASSERT_FALSE (ec); + + // successful incoming connections are stored in server_sockets to keep them alive (server side) + std::vector> server_sockets; + server_socket->on_connection ([&server_sockets] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { + server_sockets.push_back (new_connection); + return true; + }); + + // client side connection tracking + std::atomic connection_attempts = 0; + auto connect_handler = [&connection_attempts] (boost::system::error_code const & ec_a) { + ASSERT_EQ (ec_a.value (), 0); + ++connection_attempts; + }; + + // start n clients, n-1 will persist but 1 will be dropped, where n == max_ip_connections + std::vector> client_list; + client_list.reserve (max_ip_connections + 1); + + for (auto idx = 0; idx < max_ip_connections + 1; ++idx) + { + auto client = std::make_shared (*node); + client->async_connect (dst_endpoint, connect_handler); + client_list.push_back (client); + } + + auto get_tcp_max_per_ip = [&node] () { + return node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_max_per_ip, nano::stat::dir::in); + }; + + auto get_tcp_accept_successes = [&node] () { + return node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_accept_success, nano::stat::dir::in); + }; + + ASSERT_TIMELY (5s, get_tcp_accept_successes () == max_ip_connections); + ASSERT_TIMELY (5s, get_tcp_max_per_ip () == 1); + ASSERT_TIMELY (5s, connection_attempts == max_ip_connections + 1); + + node->stop (); +} + +TEST (socket, limited_subnet_address) +{ + auto address = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713"); + auto network = nano::socket_functions::get_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32. + ASSERT_EQ ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713/32", network.to_string ()); + ASSERT_EQ ("a41d:b7b2::/32", network.canonical ().to_string ()); +} + +TEST (socket, first_ipv6_subnet_address) +{ + auto address = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713"); + auto first_address = nano::socket_functions::first_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32. + ASSERT_EQ ("a41d:b7b2::", first_address.to_string ()); +} + +TEST (socket, last_ipv6_subnet_address) +{ + auto address = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713"); + auto last_address = nano::socket_functions::last_ipv6_subnet_address (address.to_v6 (), 32); // network prefix = 32. + ASSERT_EQ ("a41d:b7b2:ffff:ffff:ffff:ffff:ffff:ffff", last_address.to_string ()); +} + +TEST (socket, count_subnetwork_connections) +{ + nano::system system; + auto node = system.add_node (); + + auto address0 = boost::asio::ip::make_address ("a41d:b7b1:ffff:ffff:ffff:ffff:ffff:ffff"); // out of network prefix + auto address1 = boost::asio::ip::make_address ("a41d:b7b2:8298:cf45:672e:bd1a:e7fb:f713"); // referece address + auto address2 = boost::asio::ip::make_address ("a41d:b7b2::"); // start of the network range + auto address3 = boost::asio::ip::make_address ("a41d:b7b2::1"); + auto address4 = boost::asio::ip::make_address ("a41d:b7b2:ffff:ffff:ffff:ffff:ffff:ffff"); // end of the network range + auto address5 = boost::asio::ip::make_address ("a41d:b7b3::"); // out of the network prefix + auto address6 = boost::asio::ip::make_address ("a41d:b7b3::1"); // out of the network prefix + + auto connection0 = std::make_shared (*node); + auto connection1 = std::make_shared (*node); + auto connection2 = std::make_shared (*node); + auto connection3 = std::make_shared (*node); + auto connection4 = std::make_shared (*node); + auto connection5 = std::make_shared (*node); + auto connection6 = std::make_shared (*node); + + nano::address_socket_mmap connections_per_address; + connections_per_address.emplace (address0, connection0); + connections_per_address.emplace (address1, connection1); + connections_per_address.emplace (address2, connection2); + connections_per_address.emplace (address3, connection3); + connections_per_address.emplace (address4, connection4); + connections_per_address.emplace (address5, connection5); + connections_per_address.emplace (address6, connection6); + + // Asserts it counts only the connections for the specified address and its network prefix. + ASSERT_EQ (4, nano::socket_functions::count_subnetwork_connections (connections_per_address, address1.to_v6 (), 32)); +} + +TEST (socket, max_connections_per_subnetwork) +{ + nano::system system; + + nano::node_flags node_flags; + // disabling IP limit because it will be used the same IP address to check they come from the same subnetwork. + node_flags.disable_max_peers_per_ip = true; + node_flags.disable_max_peers_per_subnetwork = false; + auto node = system.add_node (node_flags); + ASSERT_TRUE (node->flags.disable_max_peers_per_ip); + ASSERT_FALSE (node->flags.disable_max_peers_per_subnetwork); + + auto server_port = nano::get_available_port (); + boost::asio::ip::tcp::endpoint listen_endpoint{ boost::asio::ip::address_v6::any (), server_port }; + boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), server_port }; + + const auto max_subnetwork_connections = node->network_params.network.max_peers_per_subnetwork; + ASSERT_TRUE (max_subnetwork_connections >= 1); + + const auto max_global_connections = 1000; + + auto server_socket = std::make_shared (*node, listen_endpoint, max_global_connections); + boost::system::error_code ec; + server_socket->start (ec); + ASSERT_FALSE (ec); + + // successful incoming connections are stored in server_sockets to keep them alive (server side) + std::vector> server_sockets; + server_socket->on_connection ([&server_sockets] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { + server_sockets.push_back (new_connection); + return true; + }); + + // client side connection tracking + std::atomic connection_attempts = 0; + auto connect_handler = [&connection_attempts] (boost::system::error_code const & ec_a) { + ASSERT_EQ (ec_a.value (), 0); + ++connection_attempts; + }; + + // start n clients, n-1 will persist but 1 will be dropped, where n == max_subnetwork_connections + std::vector> client_list; + client_list.reserve (max_subnetwork_connections + 1); + + for (auto idx = 0; idx < max_subnetwork_connections + 1; ++idx) + { + auto client = std::make_shared (*node); + client->async_connect (dst_endpoint, connect_handler); + client_list.push_back (client); + } + + auto get_tcp_max_per_subnetwork = [&node] () { + return node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_max_per_subnetwork, nano::stat::dir::in); + }; + + auto get_tcp_accept_successes = [&node] () { + return node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_accept_success, nano::stat::dir::in); + }; + + ASSERT_TIMELY (5s, get_tcp_accept_successes () == max_subnetwork_connections); + ASSERT_TIMELY (5s, get_tcp_max_per_subnetwork () == 1); + ASSERT_TIMELY (5s, connection_attempts == max_subnetwork_connections + 1); + + node->stop (); +} + +TEST (socket, disabled_max_peers_per_ip) +{ + nano::system system; + + nano::node_flags node_flags; + node_flags.disable_max_peers_per_ip = true; + auto node = system.add_node (node_flags); + ASSERT_TRUE (node->flags.disable_max_peers_per_ip); + + auto server_port = nano::get_available_port (); + boost::asio::ip::tcp::endpoint listen_endpoint{ boost::asio::ip::address_v6::any (), server_port }; + boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), server_port }; + + const auto max_ip_connections = node->network_params.network.max_peers_per_ip; + ASSERT_TRUE (max_ip_connections >= 1); + + const auto max_global_connections = 1000; + + auto server_socket = std::make_shared (*node, listen_endpoint, max_global_connections); + boost::system::error_code ec; + server_socket->start (ec); + ASSERT_FALSE (ec); + + // successful incoming connections are stored in server_sockets to keep them alive (server side) + std::vector> server_sockets; + server_socket->on_connection ([&server_sockets] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { + server_sockets.push_back (new_connection); + return true; + }); + + // client side connection tracking + std::atomic connection_attempts = 0; + auto connect_handler = [&connection_attempts] (boost::system::error_code const & ec_a) { + ASSERT_EQ (ec_a.value (), 0); + ++connection_attempts; + }; + + // start n clients, n-1 will persist but 1 will be dropped, where n == max_ip_connections + std::vector> client_list; + client_list.reserve (max_ip_connections + 1); + + for (auto idx = 0; idx < max_ip_connections + 1; ++idx) + { + auto client = std::make_shared (*node); + client->async_connect (dst_endpoint, connect_handler); + client_list.push_back (client); + } + + auto get_tcp_max_per_ip = [&node] () { + return node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_max_per_ip, nano::stat::dir::in); + }; + + auto get_tcp_accept_successes = [&node] () { + return node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_accept_success, nano::stat::dir::in); + }; + + ASSERT_TIMELY (5s, get_tcp_accept_successes () == max_ip_connections + 1); + ASSERT_TIMELY (5s, get_tcp_max_per_ip () == 0); + ASSERT_TIMELY (5s, connection_attempts == max_ip_connections + 1); + + node->stop (); +} + +TEST (socket, disconnection_of_silent_connections) +{ + nano::system system; + + nano::node_config config; + // Increasing the timer timeout, so we don't let the connection to timeout due to the timer checker. + config.tcp_io_timeout = std::chrono::seconds::max (); + config.network_params.network.socket_dev_idle_timeout = std::chrono::seconds::max (); + // Silent connections are connections open by external peers that don't contribute with any data. + config.network_params.network.silent_connection_tolerance_time = std::chrono::seconds{ 5 }; + + auto node = system.add_node (config); + + auto server_port = nano::get_available_port (); + boost::asio::ip::tcp::endpoint listen_endpoint{ boost::asio::ip::address_v6::any (), server_port }; + boost::asio::ip::tcp::endpoint dst_endpoint{ boost::asio::ip::address_v6::loopback (), server_port }; + + // start a server listening socket + auto server_socket = std::make_shared (*node, listen_endpoint, 1); + boost::system::error_code ec; + server_socket->start (ec); + ASSERT_FALSE (ec); + + // on a connection, a server data socket is created. The shared pointer guarantees the object's lifecycle until the end of this test. + std::shared_ptr server_data_socket; + server_socket->on_connection ([&server_data_socket] (std::shared_ptr const & new_connection, boost::system::error_code const & ec_a) { + server_data_socket = new_connection; + return true; + }); + + // Instantiates a client to simulate an incoming connection. + auto client_socket = std::make_shared (*node); + std::atomic connected{ false }; + // Opening a connection that will be closed because it remains silent during the tolerance time. + client_socket->async_connect (dst_endpoint, [client_socket, &connected] (boost::system::error_code const & ec_a) { + ASSERT_FALSE (ec_a); + connected = true; + }); + ASSERT_TIMELY (4s, connected); + // Checking the connection was closed. + ASSERT_TIMELY (10s, server_data_socket != nullptr); + ASSERT_TIMELY (10s, server_data_socket->is_closed ()); + + auto get_tcp_io_timeout_drops = [&node] () { + return node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_io_timeout_drop, nano::stat::dir::in); + }; + auto get_tcp_silent_connection_drops = [&node] () { + return node->stats.count (nano::stat::type::tcp, nano::stat::detail::tcp_silent_connection_drop, nano::stat::dir::in); + }; + // Just to ensure the disconnection wasn't due to the timer timeout. + ASSERT_EQ (0, get_tcp_io_timeout_drops ()); + // Asserts the silent checker worked. + ASSERT_EQ (1, get_tcp_silent_connection_drops ()); + + node->stop (); +} + TEST (socket, drop_policy) { auto node_flags = nano::inactive_node_flag_defaults (); @@ -33,7 +434,7 @@ TEST (socket, drop_policy) return true; }); - auto client = std::make_shared (*node, boost::none); + auto client = std::make_shared (*node); nano::transport::channel_tcp channel{ *node, client }; nano::util::counted_completion write_completion (static_cast (total_message_count)); @@ -74,6 +475,8 @@ TEST (socket, concurrent_writes) { auto node_flags = nano::inactive_node_flag_defaults (); node_flags.read_only = false; + node_flags.disable_max_peers_per_ip = true; + node_flags.disable_max_peers_per_subnetwork = true; nano::inactive_node inactivenode (nano::unique_path (), node_flags); auto node = inactivenode.node; @@ -145,7 +548,7 @@ TEST (socket, concurrent_writes) std::vector> clients; for (unsigned i = 0; i < client_count; i++) { - auto client = std::make_shared (*node, boost::none); + auto client = std::make_shared (*node); clients.push_back (client); client->async_connect (boost::asio::ip::tcp::endpoint (boost::asio::ip::address_v4::loopback (), 25000), [&connection_count_completion] (boost::system::error_code const & ec_a) { diff --git a/nano/core_test/system.cpp b/nano/core_test/system.cpp new file mode 100644 index 0000000000..1a9414c664 --- /dev/null +++ b/nano/core_test/system.cpp @@ -0,0 +1,185 @@ +#include +#include +#include + +#include + +using namespace std::chrono_literals; + +TEST (system, work_generate_limited) +{ + nano::system system; + nano::block_hash key (1); + auto min = nano::dev::network_params.work.entry; + auto max = nano::dev::network_params.work.base; + for (int i = 0; i < 5; ++i) + { + auto work = system.work_generate_limited (key, min, max); + auto difficulty = nano::dev::network_params.work.difficulty (nano::work_version::work_1, key, work); + ASSERT_GE (difficulty, min); + ASSERT_LT (difficulty, max); + } +} + +// All nodes in the system should agree on the genesis balance +TEST (system, system_genesis) +{ + nano::system system (2); + for (auto & i : system.nodes) + { + auto transaction (i->store.tx_begin_read ()); + ASSERT_EQ (nano::dev::constants.genesis_amount, i->ledger.account_balance (transaction, nano::dev::genesis->account ())); + } +} + +TEST (system, DISABLED_generate_send_existing) +{ + nano::system system (1); + auto & node1 (*system.nodes[0]); + nano::thread_runner runner (system.io_ctx, node1.config.io_threads); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + nano::keypair stake_preserver; + auto send_block (system.wallet (0)->send_action (nano::dev::genesis->account (), stake_preserver.pub, nano::dev::constants.genesis_amount / 3 * 2, true)); + nano::account_info info1; + { + auto transaction (node1.store.tx_begin_read ()); + ASSERT_FALSE (node1.store.account.get (transaction, nano::dev::genesis_key.pub, info1)); + } + std::vector accounts; + accounts.push_back (nano::dev::genesis_key.pub); + system.generate_send_existing (node1, accounts); + // Have stake_preserver receive funds after generate_send_existing so it isn't chosen as the destination + { + auto transaction (node1.store.tx_begin_write ()); + auto open_block (std::make_shared (send_block->hash (), nano::dev::genesis->account (), stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0)); + node1.work_generate_blocking (*open_block); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code); + } + ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ())); + nano::account_info info2; + { + auto transaction (node1.store.tx_begin_read ()); + ASSERT_FALSE (node1.store.account.get (transaction, nano::dev::genesis_key.pub, info2)); + } + ASSERT_NE (info1.head, info2.head); + system.deadline_set (15s); + while (info2.block_count < info1.block_count + 2) + { + ASSERT_NO_ERROR (system.poll ()); + auto transaction (node1.store.tx_begin_read ()); + ASSERT_FALSE (node1.store.account.get (transaction, nano::dev::genesis_key.pub, info2)); + } + ASSERT_EQ (info1.block_count + 2, info2.block_count); + ASSERT_EQ (info2.balance, nano::dev::constants.genesis_amount / 3); + { + auto transaction (node1.store.tx_begin_read ()); + ASSERT_NE (node1.ledger.amount (transaction, info2.head), 0); + } + system.stop (); + runner.join (); +} + +TEST (system, DISABLED_generate_send_new) +{ + nano::system system (1); + auto & node1 (*system.nodes[0]); + nano::thread_runner runner (system.io_ctx, node1.config.io_threads); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + { + auto transaction (node1.store.tx_begin_read ()); + auto iterator1 (node1.store.account.begin (transaction)); + ASSERT_NE (node1.store.account.end (), iterator1); + ++iterator1; + ASSERT_EQ (node1.store.account.end (), iterator1); + } + nano::keypair stake_preserver; + auto send_block (system.wallet (0)->send_action (nano::dev::genesis->account (), stake_preserver.pub, nano::dev::constants.genesis_amount / 3 * 2, true)); + { + auto transaction (node1.store.tx_begin_write ()); + auto open_block (std::make_shared (send_block->hash (), nano::dev::genesis->account (), stake_preserver.pub, stake_preserver.prv, stake_preserver.pub, 0)); + node1.work_generate_blocking (*open_block); + ASSERT_EQ (nano::process_result::progress, node1.ledger.process (transaction, *open_block).code); + } + ASSERT_GT (node1.balance (stake_preserver.pub), node1.balance (nano::dev::genesis->account ())); + std::vector accounts; + accounts.push_back (nano::dev::genesis_key.pub); + // This indirectly waits for online weight to stabilize, required to prevent intermittent failures + ASSERT_TIMELY (5s, node1.wallets.reps ().voting > 0); + system.generate_send_new (node1, accounts); + nano::account new_account{}; + { + auto transaction (node1.wallets.tx_begin_read ()); + auto iterator2 (system.wallet (0)->store.begin (transaction)); + if (iterator2->first != nano::dev::genesis_key.pub) + { + new_account = iterator2->first; + } + ++iterator2; + ASSERT_NE (system.wallet (0)->store.end (), iterator2); + if (iterator2->first != nano::dev::genesis_key.pub) + { + new_account = iterator2->first; + } + ++iterator2; + ASSERT_EQ (system.wallet (0)->store.end (), iterator2); + ASSERT_FALSE (new_account.is_zero ()); + } + ASSERT_TIMELY (10s, node1.balance (new_account) != 0); + system.stop (); + runner.join (); +} + +TEST (system, rep_initialize_one) +{ + nano::system system; + nano::keypair key; + system.ledger_initialization_set ({ key }); + auto node = system.add_node (); + ASSERT_EQ (nano::dev::constants.genesis_amount, node->balance (key.pub)); +} + +TEST (system, rep_initialize_two) +{ + nano::system system; + nano::keypair key0; + nano::keypair key1; + system.ledger_initialization_set ({ key0, key1 }); + auto node = system.add_node (); + ASSERT_EQ (nano::dev::constants.genesis_amount / 2, node->balance (key0.pub)); + ASSERT_EQ (nano::dev::constants.genesis_amount / 2, node->balance (key1.pub)); +} + +TEST (system, rep_initialize_one_reserve) +{ + nano::system system; + nano::keypair key; + system.ledger_initialization_set ({ key }, nano::MBAN_ratio); + auto node = system.add_node (); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio, node->balance (key.pub)); + ASSERT_EQ (nano::MBAN_ratio, node->balance (nano::dev::genesis_key.pub)); +} + +TEST (system, rep_initialize_two_reserve) +{ + nano::system system; + nano::keypair key0; + nano::keypair key1; + system.ledger_initialization_set ({ key0, key1 }, nano::MBAN_ratio); + auto node = system.add_node (); + ASSERT_EQ ((nano::dev::constants.genesis_amount - nano::MBAN_ratio) / 2, node->balance (key0.pub)); + ASSERT_EQ ((nano::dev::constants.genesis_amount - nano::MBAN_ratio) / 2, node->balance (key1.pub)); +} + +TEST (system, rep_initialize_many) +{ + nano::system system; + nano::keypair key0; + nano::keypair key1; + system.ledger_initialization_set ({ key0, key1 }, nano::MBAN_ratio); + auto node0 = system.add_node (); + ASSERT_EQ ((nano::dev::constants.genesis_amount - nano::MBAN_ratio) / 2, node0->balance (key0.pub)); + ASSERT_EQ ((nano::dev::constants.genesis_amount - nano::MBAN_ratio) / 2, node0->balance (key1.pub)); + auto node1 = system.add_node (); + ASSERT_EQ ((nano::dev::constants.genesis_amount - nano::MBAN_ratio) / 2, node1->balance (key0.pub)); + ASSERT_EQ ((nano::dev::constants.genesis_amount - nano::MBAN_ratio) / 2, node1->balance (key1.pub)); +} diff --git a/nano/core_test/telemetry.cpp b/nano/core_test/telemetry.cpp index 1ad42c4e73..1b93748f74 100644 --- a/nano/core_test/telemetry.cpp +++ b/nano/core_test/telemetry.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include @@ -284,8 +284,8 @@ TEST (telemetry, receive_from_non_listening_channel) { nano::system system; auto node = system.add_node (); - nano::telemetry_ack message (nano::telemetry_data{}); - node->network.process_message (message, node->network.udp_channels.create (node->network.endpoint ())); + nano::telemetry_ack message{ nano::dev::network_params.network, nano::telemetry_data{} }; + node->network.inbound (message, node->network.udp_channels.create (node->network.endpoint ())); // We have not sent a telemetry_req message to this endpoint, so shouldn't count telemetry_ack received from it. ASSERT_EQ (node->telemetry->telemetry_data_size (), 0); } @@ -412,7 +412,7 @@ TEST (telemetry, dos_tcp) wait_peer_connections (system); - nano::telemetry_req message; + nano::telemetry_req message{ nano::dev::network_params.network }; auto channel = node_client->network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node_server->network.endpoint ())); channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) { ASSERT_FALSE (ec); @@ -455,7 +455,7 @@ TEST (telemetry, dos_udp) wait_peer_connections (system); - nano::telemetry_req message; + nano::telemetry_req message{ nano::dev::network_params.network }; auto channel (node_client->network.udp_channels.create (node_server->network.endpoint ())); channel->send (message, [] (boost::system::error_code const & ec, size_t size_a) { ASSERT_FALSE (ec); @@ -532,7 +532,7 @@ TEST (telemetry, max_possible_size) nano::telemetry_data data; data.unknown_data.resize (nano::message_header::telemetry_size_mask.to_ulong () - nano::telemetry_data::latest_size); - nano::telemetry_ack message (data); + nano::telemetry_ack message{ nano::dev::network_params.network, data }; wait_peer_connections (system); auto channel = node_client->network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (node_server->network.endpoint ())); @@ -545,15 +545,19 @@ TEST (telemetry, max_possible_size) namespace nano { -TEST (telemetry, remove_peer_different_genesis) +// Test disabled because it's failing intermittently. +// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3512 +// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3524 +TEST (telemetry, DISABLED_remove_peer_different_genesis) { nano::system system (1); auto node0 (system.nodes[0]); ASSERT_EQ (0, node0->network.size ()); - auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); // Change genesis block to something else in this test (this is the reference telemetry processing uses). - // Possible TSAN issue in the future if something else uses this, but will only appear in tests. - node1->network_params.ledger.genesis_hash = nano::block_hash ("0"); + nano::network_params network_params{ nano::networks::nano_dev_network }; + network_params.ledger.genesis = network_params.ledger.nano_live_genesis; + nano::node_config config{ network_params }; + auto node1 (std::make_shared (system.io_ctx, nano::unique_path (), config, system.work)); node1->start (); system.nodes.push_back (node1); node0->network.merge_peer (node1->network.endpoint ()); @@ -562,8 +566,8 @@ TEST (telemetry, remove_peer_different_genesis) ASSERT_TIMELY (1s, 0 == node0->network.size ()); ASSERT_TIMELY (1s, 0 == node1->network.size ()); - ASSERT_EQ (node0->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::out), 1); - ASSERT_EQ (node1->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::out), 1); + ASSERT_GE (node0->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::out), 1); + ASSERT_GE (node1->stats.count (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::out), 1); nano::lock_guard guard (node0->network.excluded_peers.mutex); ASSERT_EQ (1, node0->network.excluded_peers.peers.get ().count (node1->network.endpoint ().address ())); @@ -580,12 +584,14 @@ TEST (telemetry, remove_peer_different_genesis_udp) nano::system system (1, nano::transport::transport_type::udp, node_flags); auto node0 (system.nodes[0]); ASSERT_EQ (0, node0->network.size ()); - auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work, node_flags)); - node1->network_params.ledger.genesis_hash = nano::block_hash ("0"); + nano::network_params network_params{ nano::networks::nano_dev_network }; + network_params.ledger.genesis = network_params.ledger.nano_live_genesis; + nano::node_config config{ network_params }; + auto node1 (std::make_shared (system.io_ctx, nano::unique_path (), config, system.work, node_flags)); node1->start (); system.nodes.push_back (node1); - auto channel0 (std::make_shared (node1->network.udp_channels, node0->network.endpoint (), node0->network_params.protocol.protocol_version)); - auto channel1 (std::make_shared (node0->network.udp_channels, node1->network.endpoint (), node1->network_params.protocol.protocol_version)); + auto channel0 (std::make_shared (node1->network.udp_channels, node0->network.endpoint (), node0->network_params.network.protocol_version)); + auto channel1 (std::make_shared (node0->network.udp_channels, node1->network.endpoint (), node1->network_params.network.protocol_version)); node0->network.send_keepalive (channel1); node1->network.send_keepalive (channel0); @@ -631,8 +637,8 @@ TEST (telemetry, remove_peer_invalid_signature) auto telemetry_data = nano::local_telemetry_data (node->ledger, node->network, node->config.bandwidth_limit, node->network_params, node->startup_time, node->default_difficulty (nano::work_version::work_1), node->node_id); // Change anything so that the signed message is incorrect telemetry_data.block_count = 0; - auto telemetry_ack = nano::telemetry_ack (telemetry_data); - node->network.process_message (telemetry_ack, channel); + auto telemetry_ack = nano::telemetry_ack{ nano::dev::network_params.network, telemetry_data }; + node->network.inbound (telemetry_ack, channel); ASSERT_TIMELY (10s, node->stats.count (nano::stat::type::telemetry, nano::stat::detail::invalid_signature) > 0); ASSERT_NO_ERROR (system.poll_until_true (3s, [&node, address = channel->get_endpoint ().address ()] () -> bool { diff --git a/nano/core_test/toml.cpp b/nano/core_test/toml.cpp index 45e56c841e..19d5c25070 100644 --- a/nano/core_test/toml.cpp +++ b/nano/core_test/toml.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include #include @@ -69,7 +70,7 @@ TEST (toml, daemon_config_update_array) { nano::tomlconfig t; boost::filesystem::path data_path ("."); - nano::daemon_config c (data_path); + nano::daemon_config c{ data_path, nano::dev::network_params }; c.node.preconfigured_peers.push_back ("dev-peer.org"); c.serialize_toml (t); c.deserialize_toml (t); @@ -88,8 +89,8 @@ TEST (toml, rpc_config_deserialize_defaults) nano::tomlconfig t; t.read (ss); - nano::rpc_config conf; - nano::rpc_config defaults; + nano::rpc_config conf{ nano::dev::network_params.network }; + nano::rpc_config defaults{ nano::dev::network_params.network }; conf.deserialize_toml (t); ASSERT_FALSE (t.get_error ()) << t.get_error ().get_message (); @@ -163,11 +164,11 @@ TEST (toml, daemon_config_deserialize_defaults) ASSERT_EQ (conf.node.external_address, defaults.node.external_address); ASSERT_EQ (conf.node.external_port, defaults.node.external_port); ASSERT_EQ (conf.node.io_threads, defaults.node.io_threads); - ASSERT_EQ (conf.node.deprecated_lmdb_max_dbs, defaults.node.deprecated_lmdb_max_dbs); ASSERT_EQ (conf.node.max_work_generate_multiplier, defaults.node.max_work_generate_multiplier); ASSERT_EQ (conf.node.network_threads, defaults.node.network_threads); ASSERT_EQ (conf.node.secondary_work_peers, defaults.node.secondary_work_peers); ASSERT_EQ (conf.node.online_weight_minimum, defaults.node.online_weight_minimum); + ASSERT_EQ (conf.node.rep_crawler_weight_minimum, defaults.node.rep_crawler_weight_minimum); ASSERT_EQ (conf.node.election_hint_weight_percent, defaults.node.election_hint_weight_percent); ASSERT_EQ (conf.node.password_fanout, defaults.node.password_fanout); ASSERT_EQ (conf.node.peering_port, defaults.node.peering_port); @@ -214,6 +215,7 @@ TEST (toml, daemon_config_deserialize_defaults) ASSERT_EQ (conf.node.logging.active_update_value, defaults.node.logging.active_update_value); ASSERT_EQ (conf.node.logging.upnp_details_logging_value, defaults.node.logging.upnp_details_logging_value); ASSERT_EQ (conf.node.logging.vote_logging_value, defaults.node.logging.vote_logging_value); + ASSERT_EQ (conf.node.logging.rep_crawler_logging_value, defaults.node.logging.rep_crawler_logging_value); ASSERT_EQ (conf.node.logging.work_generation_time_value, defaults.node.logging.work_generation_time_value); ASSERT_EQ (conf.node.websocket_config.enabled, defaults.node.websocket_config.enabled); @@ -405,12 +407,13 @@ TEST (toml, daemon_config_deserialize_no_defaults) lmdb_max_dbs = 999 network_threads = 999 online_weight_minimum = "999" + rep_crawler_weight_minimum = "999" election_hint_weight_percent = 19 password_fanout = 999 peering_port = 999 pow_sleep_interval= 999 preconfigured_peers = ["dev.org"] - preconfigured_representatives = ["nano_3arg3asgtigae3xckabaaewkx3bzsh7nwz7jkmjos79ihyaxwphhm6qgjps4"] + preconfigured_representatives = ["bano_3arg3asgtigae3xckabaaewkx3bzsh7nwz7jkmjos79ihyaxwphhm6qgjps4"] receive_minimum = "999" signature_checker_threads = 999 tcp_incoming_connections_max = 999 @@ -480,6 +483,7 @@ TEST (toml, daemon_config_deserialize_no_defaults) active_update = true upnp_details = true vote = true + rep_crawler = true work_generation_time = false [node.statistics.log] @@ -564,7 +568,6 @@ TEST (toml, daemon_config_deserialize_no_defaults) ASSERT_NE (conf.node.external_address, defaults.node.external_address); ASSERT_NE (conf.node.external_port, defaults.node.external_port); ASSERT_NE (conf.node.io_threads, defaults.node.io_threads); - ASSERT_NE (conf.node.deprecated_lmdb_max_dbs, defaults.node.deprecated_lmdb_max_dbs); ASSERT_NE (conf.node.max_work_generate_multiplier, defaults.node.max_work_generate_multiplier); ASSERT_NE (conf.node.frontiers_confirmation, defaults.node.frontiers_confirmation); ASSERT_NE (conf.node.network_threads, defaults.node.network_threads); @@ -572,6 +575,7 @@ TEST (toml, daemon_config_deserialize_no_defaults) ASSERT_NE (conf.node.max_pruning_age, defaults.node.max_pruning_age); ASSERT_NE (conf.node.max_pruning_depth, defaults.node.max_pruning_depth); ASSERT_NE (conf.node.online_weight_minimum, defaults.node.online_weight_minimum); + ASSERT_NE (conf.node.rep_crawler_weight_minimum, defaults.node.rep_crawler_weight_minimum); ASSERT_NE (conf.node.election_hint_weight_percent, defaults.node.election_hint_weight_percent); ASSERT_NE (conf.node.password_fanout, defaults.node.password_fanout); ASSERT_NE (conf.node.peering_port, defaults.node.peering_port); @@ -618,6 +622,7 @@ TEST (toml, daemon_config_deserialize_no_defaults) ASSERT_NE (conf.node.logging.active_update_value, defaults.node.logging.active_update_value); ASSERT_NE (conf.node.logging.upnp_details_logging_value, defaults.node.logging.upnp_details_logging_value); ASSERT_NE (conf.node.logging.vote_logging_value, defaults.node.logging.vote_logging_value); + ASSERT_NE (conf.node.logging.rep_crawler_logging_value, defaults.node.logging.rep_crawler_logging_value); ASSERT_NE (conf.node.logging.work_generation_time_value, defaults.node.logging.work_generation_time_value); ASSERT_NE (conf.node.websocket_config.enabled, defaults.node.websocket_config.enabled); @@ -659,7 +664,8 @@ TEST (toml, daemon_config_deserialize_no_defaults) ASSERT_NE (conf.node.lmdb_config.max_databases, defaults.node.lmdb_config.max_databases); ASSERT_NE (conf.node.lmdb_config.map_size, defaults.node.lmdb_config.map_size); - ASSERT_NE (conf.node.rocksdb_config.enable, defaults.node.rocksdb_config.enable); + ASSERT_TRUE (conf.node.rocksdb_config.enable); + ASSERT_EQ (nano::rocksdb_config::using_rocksdb_in_tests (), defaults.node.rocksdb_config.enable); ASSERT_NE (conf.node.rocksdb_config.memory_multiplier, defaults.node.rocksdb_config.memory_multiplier); ASSERT_NE (conf.node.rocksdb_config.io_threads, defaults.node.rocksdb_config.io_threads); } @@ -718,8 +724,8 @@ TEST (toml, rpc_config_deserialize_no_defaults) nano::tomlconfig toml; toml.read (ss); - nano::rpc_config conf; - nano::rpc_config defaults; + nano::rpc_config conf{ nano::dev::network_params.network }; + nano::rpc_config defaults{ nano::dev::network_params.network }; conf.deserialize_toml (toml); ASSERT_FALSE (toml.get_error ()) << toml.get_error ().get_message (); @@ -753,8 +759,8 @@ TEST (toml, rpc_config_no_required) nano::tomlconfig toml; toml.read (ss); - nano::rpc_config conf; - nano::rpc_config defaults; + nano::rpc_config conf{ nano::dev::network_params.network }; + nano::rpc_config defaults{ nano::dev::network_params.network }; conf.deserialize_toml (toml); ASSERT_FALSE (toml.get_error ()) << toml.get_error ().get_message (); @@ -898,3 +904,61 @@ TEST (toml, daemon_read_config) ASSERT_EQ (error.get_message (), expected_message2); } } + +/** Deserialize an tls config with non-default values */ +TEST (toml, tls_config_deserialize_no_defaults) +{ + std::stringstream ss; + + // A config file with values that differs from devnet defaults + ss << R"toml( + enable_https=true + enable_wss=true + verbose_logging=true + server_cert_path="xyz.cert.pem" + server_key_path="xyz.key.pem" + server_key_passphrase="xyz" + server_dh_path="xyz.pem" + )toml"; + + nano::tomlconfig toml; + toml.read (ss); + nano::tls_config conf; + nano::tls_config defaults; + conf.deserialize_toml (toml); + + ASSERT_FALSE (toml.get_error ()) << toml.get_error ().get_message (); + + ASSERT_NE (conf.enable_https, defaults.enable_https); + ASSERT_NE (conf.enable_wss, defaults.enable_wss); + ASSERT_NE (conf.verbose_logging, defaults.verbose_logging); + ASSERT_NE (conf.server_cert_path, defaults.server_cert_path); + ASSERT_NE (conf.server_key_path, defaults.server_key_path); + ASSERT_NE (conf.server_key_passphrase, defaults.server_key_passphrase); + ASSERT_NE (conf.server_dh_path, defaults.server_dh_path); +} + +/** Empty tls config file should match a default config object, and there should be no required values. */ +TEST (toml, tls_config_defaults) +{ + std::stringstream ss; + + // A config with no values + ss << R"toml()toml"; + + nano::tomlconfig toml; + toml.read (ss); + nano::tls_config conf; + nano::tls_config defaults; + conf.deserialize_toml (toml); + + ASSERT_FALSE (toml.get_error ()) << toml.get_error ().get_message (); + + ASSERT_EQ (conf.enable_https, defaults.enable_wss); + ASSERT_EQ (conf.enable_wss, defaults.enable_wss); + ASSERT_EQ (conf.verbose_logging, defaults.verbose_logging); + ASSERT_EQ (conf.server_cert_path, defaults.server_cert_path); + ASSERT_EQ (conf.server_key_path, defaults.server_key_path); + ASSERT_EQ (conf.server_key_passphrase, defaults.server_key_passphrase); + ASSERT_EQ (conf.server_dh_path, defaults.server_dh_path); +} diff --git a/nano/core_test/uint256_union.cpp b/nano/core_test/uint256_union.cpp index d26ca15d55..e5f87b3ca4 100644 --- a/nano/core_test/uint256_union.cpp +++ b/nano/core_test/uint256_union.cpp @@ -1,8 +1,11 @@ +#include #include #include #include +#include + namespace { template @@ -99,11 +102,11 @@ TEST (uint128_union, balance_format) { ASSERT_EQ ("0", nano::amount (nano::uint128_t ("0")).format_balance (nano::BAN_ratio, 0, false)); ASSERT_EQ ("0", nano::amount (nano::uint128_t ("0")).format_balance (nano::BAN_ratio, 2, true)); - ASSERT_EQ ("340,282,366", nano::amount (nano::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")).format_balance (nano::BAN_ratio, 0, true)); - ASSERT_EQ ("340,282,366.920938463463374607431768211455", nano::amount (nano::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")).format_balance (nano::BAN_ratio, 64, true)); + ASSERT_EQ ("3,402,823,669", nano::amount (nano::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")).format_balance (nano::BAN_ratio, 0, true)); + ASSERT_EQ ("3,402,823,669.20938463463374607431768211455", nano::amount (nano::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF")).format_balance (nano::BAN_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::BAN_ratio, 0, true)); - ASSERT_EQ ("340,282,366.920938463463374607431768211454", nano::amount (nano::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (nano::BAN_ratio, 64, true)); + ASSERT_EQ ("3,402,823,669", nano::amount (nano::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (nano::BAN_ratio, 0, true)); + ASSERT_EQ ("3,402,823,669.20938463463374607431768211454", nano::amount (nano::uint128_t ("0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (nano::BAN_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::BAN_ratio, 0, true)); ASSERT_EQ ("170,141,183.460469231731687303715884105726", nano::amount (nano::uint128_t ("0x7FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFE")).format_balance (nano::BAN_ratio, 64, true)); @@ -369,21 +372,21 @@ TEST (uint256_union, decode_nano_variant) { nano::account key; ASSERT_FALSE (key.decode_account ("ban_1111111111111111111111111111111111111111111111111111hifc8npp")); - ASSERT_FALSE (key.decode_account ("nano_1111111111111111111111111111111111111111111111111111hifc8npp")); + ASSERT_FALSE (key.decode_account ("ban_1111111111111111111111111111111111111111111111111111hifc8npp")); } TEST (uint256_union, account_transcode) { nano::account value; - auto text (nano::dev_genesis_key.pub.to_account ()); + auto text (nano::dev::genesis_key.pub.to_account ()); ASSERT_FALSE (value.decode_account (text)); - ASSERT_EQ (nano::dev_genesis_key.pub, value); + ASSERT_EQ (nano::dev::genesis_key.pub, value); /* * Handle different offsets for the underscore separator * for "ban_" prefixed and "nano_" prefixed accounts */ - unsigned offset = (text.front () == 'x') ? 3 : 4; + unsigned offset = (text.front () == 'b') ? 3 : 4; ASSERT_EQ ('_', text[offset]); text[offset] = '-'; nano::account value2; @@ -401,7 +404,7 @@ TEST (uint256_union, account_encode_lex) /* * Handle different lengths for "ban_" prefixed and "nano_" prefixed accounts */ - unsigned length = (min_text.front () == 'x') ? 64 : 65; + unsigned length = (min_text.front () == 'b') ? 64 : 65; ASSERT_EQ (length, min_text.size ()); ASSERT_EQ (length, max_text.size ()); @@ -567,3 +570,19 @@ void check_operator_greater_than (Num lhs, Num rhs) ASSERT_FALSE (rhs > rhs); } } + +TEST (random_pool, multithreading) +{ + std::vector threads; + for (auto i = 0; i < 100; ++i) + { + threads.emplace_back ([] () { + nano::uint256_union number; + nano::random_pool::generate_block (number.bytes.data (), number.bytes.size ()); + }); + } + for (auto & i : threads) + { + i.join (); + } +} diff --git a/nano/core_test/vote_processor.cpp b/nano/core_test/vote_processor.cpp index 72869e4ce1..d262462c35 100644 --- a/nano/core_test/vote_processor.cpp +++ b/nano/core_test/vote_processor.cpp @@ -1,6 +1,6 @@ #include -#include #include +#include #include #include @@ -11,9 +11,8 @@ TEST (vote_processor, codes) { nano::system system (1); auto & node (*system.nodes[0]); - nano::genesis genesis; nano::keypair key; - auto vote (std::make_shared (key.pub, key.prv, 1, std::vector{ genesis.open->hash () })); + auto vote (std::make_shared (key.pub, key.prv, nano::vote::timestamp_min * 1, 0, std::vector{ nano::dev::genesis->hash () })); auto vote_invalid = std::make_shared (*vote); vote_invalid->signature.bytes[0] ^= 1; auto channel (std::make_shared (node)); @@ -28,9 +27,8 @@ TEST (vote_processor, codes) ASSERT_EQ (nano::vote_code::indeterminate, node.vote_processor.vote_blocking (vote, channel)); // First vote from an account for an ongoing election - genesis.open->sideband_set (nano::block_sideband (nano::genesis_account, 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); - node.block_confirm (genesis.open); - ASSERT_NE (nullptr, node.active.election (genesis.open->qualified_root ())); + node.block_confirm (nano::dev::genesis); + ASSERT_NE (nullptr, node.active.election (nano::dev::genesis->qualified_root ())); ASSERT_EQ (nano::vote_code::vote, node.vote_processor.vote_blocking (vote, channel)); // Processing the same vote is a replay @@ -39,14 +37,8 @@ TEST (vote_processor, codes) // Invalid takes precedence ASSERT_EQ (nano::vote_code::invalid, node.vote_processor.vote_blocking (vote_invalid, channel)); - // A higher timestamp is not a replay - ++vote->timestamp; - ASSERT_EQ (nano::vote_code::invalid, node.vote_processor.vote_blocking (vote, channel)); - vote->signature = nano::sign_message (key.prv, key.pub, vote->hash ()); - ASSERT_EQ (nano::vote_code::vote, node.vote_processor.vote_blocking (vote, channel)); - // Once the election is removed (confirmed / dropped) the vote is again indeterminate - node.active.erase (*genesis.open); + node.active.erase (*nano::dev::genesis); ASSERT_EQ (nano::vote_code::indeterminate, node.vote_processor.vote_blocking (vote, channel)); } @@ -54,14 +46,11 @@ TEST (vote_processor, flush) { nano::system system (1); auto & node (*system.nodes[0]); - nano::genesis genesis; - auto vote (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 1, std::vector{ genesis.open->hash () })); auto channel (std::make_shared (node)); for (unsigned i = 0; i < 2000; ++i) { - auto new_vote (std::make_shared (*vote)); - node.vote_processor.vote (new_vote, channel); - ++vote->timestamp; // invalidates votes without signing again + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::vote::timestamp_min * (1 + i), 0, std::vector{ nano::dev::genesis->hash () }); + node.vote_processor.vote (vote, channel); } node.vote_processor.flush (); ASSERT_TRUE (node.vote_processor.empty ()); @@ -71,16 +60,14 @@ TEST (vote_processor, invalid_signature) { nano::system system{ 1 }; auto & node = *system.nodes[0]; - nano::genesis genesis; nano::keypair key; - auto vote = std::make_shared (key.pub, key.prv, 1, std::vector{ genesis.open->hash () }); + auto vote = std::make_shared (key.pub, key.prv, nano::vote::timestamp_min * 1, 0, std::vector{ nano::dev::genesis->hash () }); auto vote_invalid = std::make_shared (*vote); vote_invalid->signature.bytes[0] ^= 1; auto channel = std::make_shared (node); - genesis.open->sideband_set (nano::block_sideband (nano::genesis_account, 0, nano::genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); - node.block_confirm (genesis.open); - auto election = node.active.election (genesis.open->qualified_root ()); + node.block_confirm (nano::dev::genesis); + auto election = node.active.election (nano::dev::genesis->qualified_root ()); ASSERT_TRUE (election); ASSERT_EQ (1, election->votes ().size ()); node.vote_processor.vote (vote_invalid, channel); @@ -97,9 +84,8 @@ TEST (vote_processor, no_capacity) nano::node_flags node_flags; node_flags.vote_processor_capacity = 0; auto & node (*system.add_node (node_flags)); - nano::genesis genesis; nano::keypair key; - auto vote (std::make_shared (key.pub, key.prv, 1, std::vector{ genesis.open->hash () })); + auto vote (std::make_shared (key.pub, key.prv, nano::vote::timestamp_min * 1, 0, std::vector{ nano::dev::genesis->hash () })); auto channel (std::make_shared (node)); ASSERT_TRUE (node.vote_processor.vote (vote, channel)); } @@ -110,9 +96,8 @@ TEST (vote_processor, overflow) nano::node_flags node_flags; node_flags.vote_processor_capacity = 1; auto & node (*system.add_node (node_flags)); - nano::genesis genesis; nano::keypair key; - auto vote (std::make_shared (key.pub, key.prv, 1, std::vector{ genesis.open->hash () })); + auto vote (std::make_shared (key.pub, key.prv, nano::vote::timestamp_min * 1, 0, std::vector{ nano::dev::genesis->hash () })); auto channel (std::make_shared (node)); // No way to lock the processor, but queueing votes in quick succession must result in overflow @@ -148,16 +133,16 @@ TEST (vote_processor, weights) nano::keypair key1; nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (1)->insert_adhoc (key0.prv); system.wallet (2)->insert_adhoc (key1.prv); system.wallet (3)->insert_adhoc (key2.prv); system.wallet (1)->store.representative_set (system.nodes[1]->wallets.tx_begin_write (), key0.pub); system.wallet (2)->store.representative_set (system.nodes[2]->wallets.tx_begin_write (), key1.pub); system.wallet (3)->store.representative_set (system.nodes[3]->wallets.tx_begin_write (), key2.pub); - system.wallet (0)->send_sync (nano::dev_genesis_key.pub, key0.pub, level0); - system.wallet (0)->send_sync (nano::dev_genesis_key.pub, key1.pub, level1); - system.wallet (0)->send_sync (nano::dev_genesis_key.pub, key2.pub, level2); + system.wallet (0)->send_sync (nano::dev::genesis_key.pub, key0.pub, level0); + system.wallet (0)->send_sync (nano::dev::genesis_key.pub, key1.pub, level1); + system.wallet (0)->send_sync (nano::dev::genesis_key.pub, key2.pub, level2); // Wait for representatives ASSERT_TIMELY (10s, node.ledger.cache.rep_weights.get_rep_amounts ().size () == 4); @@ -175,118 +160,162 @@ TEST (vote_processor, weights) ASSERT_NE (node.vote_processor.representatives_2.end (), node.vote_processor.representatives_2.find (key2.pub)); ASSERT_EQ (node.vote_processor.representatives_3.end (), node.vote_processor.representatives_3.find (key2.pub)); - ASSERT_NE (node.vote_processor.representatives_1.end (), node.vote_processor.representatives_1.find (nano::dev_genesis_key.pub)); - ASSERT_NE (node.vote_processor.representatives_2.end (), node.vote_processor.representatives_2.find (nano::dev_genesis_key.pub)); - ASSERT_NE (node.vote_processor.representatives_3.end (), node.vote_processor.representatives_3.find (nano::dev_genesis_key.pub)); + ASSERT_NE (node.vote_processor.representatives_1.end (), node.vote_processor.representatives_1.find (nano::dev::genesis_key.pub)); + ASSERT_NE (node.vote_processor.representatives_2.end (), node.vote_processor.representatives_2.find (nano::dev::genesis_key.pub)); + ASSERT_NE (node.vote_processor.representatives_3.end (), node.vote_processor.representatives_3.find (nano::dev::genesis_key.pub)); } } +// Issue that tracks last changes on this test: https://github.com/nanocurrency/nano-node/issues/3485 +// Reopen in case the nondeterministic failure appears again. +// Checks local votes (a vote with a key that is in the node's wallet) are not re-broadcast when received. +// Nodes should not relay their own votes TEST (vote_processor, no_broadcast_local) { nano::system system; nano::node_flags flags; flags.disable_request_loop = true; - auto & node (*system.add_node (flags)); - system.add_node (flags); + nano::node_config config1, config2; + config1.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; + auto & node (*system.add_node (config1, flags)); + config2.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; + config2.peering_port = nano::get_available_port (); + system.add_node (config2, flags); nano::block_builder builder; std::error_code ec; // Reduce the weight of genesis to 2x default min voting weight nano::keypair key; std::shared_ptr send = builder.state () - .account (nano::dev_genesis_key.pub) - .representative (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) + .account (nano::dev::genesis_key.pub) + .representative (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) .balance (2 * node.config.vote_minimum.number ()) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build (ec); ASSERT_FALSE (ec); ASSERT_EQ (nano::process_result::progress, node.process_local (send).code); - ASSERT_EQ (2 * node.config.vote_minimum.number (), node.weight (nano::dev_genesis_key.pub)); - // Insert account in wallet - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + ASSERT_TIMELY (10s, !node.active.empty ()); + ASSERT_EQ (2 * node.config.vote_minimum.number (), node.weight (nano::dev::genesis_key.pub)); + // Insert account in wallet. Votes on node are not enabled. + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + // Ensure that the node knows the genesis key in its wallet. node.wallets.compute_reps (); - ASSERT_TRUE (node.wallets.reps ().exists (nano::dev_genesis_key.pub)); - ASSERT_FALSE (node.wallets.reps ().have_half_rep ()); - // Process a vote - auto vote = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), std::vector{ send->hash () }); + ASSERT_TRUE (node.wallets.reps ().exists (nano::dev::genesis_key.pub)); + ASSERT_FALSE (node.wallets.reps ().have_half_rep ()); // Genesis balance remaining after `send' is less than the half_rep threshold + // Process a vote with a key that is in the local wallet. + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::milliseconds_since_epoch (), nano::vote::duration_max, std::vector{ send->hash () }); ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote)); - // Make sure the vote was processed + // Make sure the vote was processed. auto election (node.active.election (send->qualified_root ())); ASSERT_NE (nullptr, election); auto votes (election->votes ()); - auto existing (votes.find (nano::dev_genesis_key.pub)); + auto existing (votes.find (nano::dev::genesis_key.pub)); ASSERT_NE (votes.end (), existing); - ASSERT_EQ (vote->timestamp, existing->second.timestamp); - // Ensure the vote, from a local representative, was not broadcast on processing - it should be flooded on generation instead + ASSERT_EQ (vote->timestamp (), existing->second.timestamp); + // Ensure the vote, from a local representative, was not broadcast on processing - it should be flooded on vote generation instead. ASSERT_EQ (0, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); ASSERT_EQ (1, node.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::out)); +} - // Repeat test with no representative - // Erase account from the wallet - system.wallet (0)->store.erase (node.wallets.tx_begin_write (), nano::dev_genesis_key.pub); - node.wallets.compute_reps (); - ASSERT_FALSE (node.wallets.reps ().exists (nano::dev_genesis_key.pub)); - - std::shared_ptr send2 = builder.state () - .account (nano::dev_genesis_key.pub) - .representative (nano::dev_genesis_key.pub) - .previous (send->hash ()) - .balance (node.config.vote_minimum) - .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (send->hash ())) - .build (ec); +// Issue that tracks last changes on this test: https://github.com/nanocurrency/nano-node/issues/3485 +// Reopen in case the nondeterministic failure appears again. +// Checks non-local votes (a vote with a key that is not in the node's wallet) are re-broadcast when received. +// Done without a representative. +TEST (vote_processor, local_broadcast_without_a_representative) +{ + nano::system system; + nano::node_flags flags; + flags.disable_request_loop = true; + nano::node_config config1, config2; + config1.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; + auto & node (*system.add_node (config1, flags)); + config2.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; + config2.peering_port = nano::get_available_port (); + system.add_node (config2, flags); + nano::block_builder builder; + std::error_code ec; + // Reduce the weight of genesis to 2x default min voting weight + nano::keypair key; + std::shared_ptr send = builder.state () + .account (nano::dev::genesis_key.pub) + .representative (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .balance (node.config.vote_minimum.number ()) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) + .build (ec); ASSERT_FALSE (ec); - ASSERT_EQ (nano::process_result::progress, node.process_local (send2).code); - ASSERT_EQ (node.config.vote_minimum, node.weight (nano::dev_genesis_key.pub)); - node.block_confirm (send2); - // Process a vote - auto vote2 = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), std::vector{ send2->hash () }); - ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote2)); - // Make sure the vote was processed - auto election2 (node.active.election (send2->qualified_root ())); - ASSERT_NE (nullptr, election2); - auto votes2 (election2->votes ()); - auto existing2 (votes2.find (nano::dev_genesis_key.pub)); - ASSERT_NE (votes2.end (), existing2); - ASSERT_EQ (vote2->timestamp, existing2->second.timestamp); + ASSERT_EQ (nano::process_result::progress, node.process_local (send).code); + ASSERT_TIMELY (10s, !node.active.empty ()); + ASSERT_EQ (node.config.vote_minimum, node.weight (nano::dev::genesis_key.pub)); + node.block_confirm (send); + // Process a vote without a representative + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::milliseconds_since_epoch (), nano::vote::duration_max, std::vector{ send->hash () }); + ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote)); + // Make sure the vote was processed. + auto election (node.active.election (send->qualified_root ())); + ASSERT_NE (nullptr, election); + auto votes (election->votes ()); + auto existing (votes.find (nano::dev::genesis_key.pub)); + ASSERT_NE (votes.end (), existing); + ASSERT_EQ (vote->timestamp (), existing->second.timestamp); // Ensure the vote was broadcast ASSERT_EQ (1, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); - ASSERT_EQ (2, node.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::out)); + ASSERT_EQ (1, node.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::out)); +} - // Repeat test with a PR in the wallet - // Increase the genesis weight again - std::shared_ptr open = builder.state () - .account (key.pub) - .representative (nano::dev_genesis_key.pub) - .previous (0) - .balance (nano::genesis_amount - 2 * node.config.vote_minimum.number ()) - .link (send->hash ()) - .sign (key.prv, key.pub) - .work (*system.work.generate (key.pub)) +// Issue that tracks last changes on this test: https://github.com/nanocurrency/nano-node/issues/3485 +// Reopen in case the nondeterministic failure appears again. +// Checks local votes (a vote with a key that is in the node's wallet) are not re-broadcast when received. +// Done with a principal representative. +TEST (vote_processor, no_broadcast_local_with_a_principal_representative) +{ + nano::system system; + nano::node_flags flags; + flags.disable_request_loop = true; + nano::node_config config1, config2; + config1.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; + auto & node (*system.add_node (config1, flags)); + config2.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; + config2.peering_port = nano::get_available_port (); + system.add_node (config2, flags); + nano::block_builder builder; + std::error_code ec; + // Reduce the weight of genesis to 2x default min voting weight + nano::keypair key; + std::shared_ptr send = builder.state () + .account (nano::dev::genesis_key.pub) + .representative (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .balance (nano::dev::constants.genesis_amount - 2 * node.config.vote_minimum.number ()) + .link (key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build (ec); ASSERT_FALSE (ec); - ASSERT_EQ (nano::process_result::progress, node.process_local (open).code); - ASSERT_EQ (nano::genesis_amount - node.config.vote_minimum.number (), node.weight (nano::dev_genesis_key.pub)); - node.block_confirm (open); - // Insert account in wallet - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + ASSERT_EQ (nano::process_result::progress, node.process_local (send).code); + ASSERT_TIMELY (10s, !node.active.empty ()); + ASSERT_EQ (nano::dev::constants.genesis_amount - 2 * node.config.vote_minimum.number (), node.weight (nano::dev::genesis_key.pub)); + // Insert account in wallet. Votes on node are not enabled. + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + // Ensure that the node knows the genesis key in its wallet. node.wallets.compute_reps (); - ASSERT_TRUE (node.wallets.reps ().exists (nano::dev_genesis_key.pub)); - ASSERT_TRUE (node.wallets.reps ().have_half_rep ()); - // Process a vote - auto vote3 = std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::milliseconds_since_epoch (), std::vector{ open->hash () }); - ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote3)); - // Make sure the vote was processed - auto election3 (node.active.election (open->qualified_root ())); - ASSERT_NE (nullptr, election3); - auto votes3 (election3->votes ()); - auto existing3 (votes3.find (nano::dev_genesis_key.pub)); - ASSERT_NE (votes3.end (), existing3); - ASSERT_EQ (vote3->timestamp, existing3->second.timestamp); - // Ensure the vote wass not broadcasst - ASSERT_EQ (1, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); - ASSERT_EQ (3, node.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::out)); + ASSERT_TRUE (node.wallets.reps ().exists (nano::dev::genesis_key.pub)); + ASSERT_TRUE (node.wallets.reps ().have_half_rep ()); // Genesis balance after `send' is over both half_rep and PR threshold. + // Process a vote with a key that is in the local wallet. + auto vote = std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::milliseconds_since_epoch (), nano::vote::duration_max, std::vector{ send->hash () }); + ASSERT_EQ (nano::vote_code::vote, node.active.vote (vote)); + // Make sure the vote was processed. + auto election (node.active.election (send->qualified_root ())); + ASSERT_NE (nullptr, election); + auto votes (election->votes ()); + auto existing (votes.find (nano::dev::genesis_key.pub)); + ASSERT_NE (votes.end (), existing); + ASSERT_EQ (vote->timestamp (), existing->second.timestamp); + // Ensure the vote was not broadcast. + ASSERT_EQ (0, node.stats.count (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::out)); + ASSERT_EQ (1, node.stats.count (nano::stat::type::message, nano::stat::detail::publish, nano::stat::dir::out)); } diff --git a/nano/core_test/voting.cpp b/nano/core_test/voting.cpp index a59b40df39..80048bf2cd 100644 --- a/nano/core_test/voting.cpp +++ b/nano/core_test/voting.cpp @@ -1,6 +1,6 @@ #include -#include #include +#include #include #include @@ -11,8 +11,7 @@ namespace nano { TEST (local_vote_history, basic) { - nano::network_params params; - nano::local_vote_history history{ params.voting }; + nano::local_vote_history history{ nano::dev::network_params.voting }; ASSERT_FALSE (history.exists (1)); ASSERT_FALSE (history.exists (2)); ASSERT_TRUE (history.votes (1).empty ()); @@ -61,7 +60,7 @@ TEST (vote_generator, cache) nano::system system (1); auto & node (*system.nodes[0]); auto epoch1 = system.upgrade_genesis_epoch (node, nano::epoch::epoch_1); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); node.active.generator.add (epoch1->root (), epoch1->hash ()); ASSERT_TIMELY (1s, !node.history.votes (epoch1->root (), epoch1->hash ()).empty ()); auto votes (node.history.votes (epoch1->root (), epoch1->hash ())); @@ -75,14 +74,14 @@ TEST (vote_generator, multiple_representatives) auto & node (*system.nodes[0]); nano::keypair key1, key2, key3; auto & wallet (*system.wallet (0)); - wallet.insert_adhoc (nano::dev_genesis_key.prv); + wallet.insert_adhoc (nano::dev::genesis_key.prv); wallet.insert_adhoc (key1.prv); wallet.insert_adhoc (key2.prv); wallet.insert_adhoc (key3.prv); auto const amount = 100 * nano::MBAN_ratio; - wallet.send_sync (nano::dev_genesis_key.pub, key1.pub, amount); - wallet.send_sync (nano::dev_genesis_key.pub, key2.pub, amount); - wallet.send_sync (nano::dev_genesis_key.pub, key3.pub, amount); + wallet.send_sync (nano::dev::genesis_key.pub, key1.pub, amount); + wallet.send_sync (nano::dev::genesis_key.pub, key2.pub, amount); + wallet.send_sync (nano::dev::genesis_key.pub, key3.pub, amount); ASSERT_TIMELY (3s, node.balance (key1.pub) == amount && node.balance (key2.pub) == amount && node.balance (key3.pub) == amount); wallet.change_sync (key1.pub, key1.pub); wallet.change_sync (key2.pub, key2.pub); @@ -90,12 +89,12 @@ TEST (vote_generator, multiple_representatives) ASSERT_TRUE (node.weight (key1.pub) == amount && node.weight (key2.pub) == amount && node.weight (key3.pub) == amount); node.wallets.compute_reps (); ASSERT_EQ (4, node.wallets.reps ().voting); - auto hash = wallet.send_sync (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, 1); + auto hash = wallet.send_sync (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, 1); auto send = node.block (hash); ASSERT_NE (nullptr, send); ASSERT_TIMELY (5s, node.history.votes (send->root (), send->hash ()).size () == 4); auto votes (node.history.votes (send->root (), send->hash ())); - for (auto const & account : { key1.pub, key2.pub, key3.pub, nano::dev_genesis_key.pub }) + for (auto const & account : { key1.pub, key2.pub, key3.pub, nano::dev::genesis_key.pub }) { auto existing (std::find_if (votes.begin (), votes.end (), [&account] (std::shared_ptr const & vote_a) -> bool { return vote_a->account == account; @@ -108,11 +107,11 @@ TEST (vote_generator, session) { nano::system system (1); auto node (system.nodes[0]); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::vote_generator_session generator_session (node->active.generator); boost::thread thread ([node, &generator_session] () { nano::thread_role::set (nano::thread_role::name::request_loop); - generator_session.add (nano::genesis_account, nano::genesis_hash); + generator_session.add (nano::dev::genesis->account (), nano::dev::genesis->hash ()); ASSERT_EQ (0, node->stats.count (nano::stat::type::vote, nano::stat::detail::vote_indeterminate)); generator_session.flush (); }); @@ -162,37 +161,37 @@ TEST (vote_spacing, vote_generator) node_flags.disable_search_pending = true; auto & node = *system.add_node (config, node_flags); auto & wallet = *system.wallet (0); - wallet.insert_adhoc (nano::dev_genesis_key.prv); + wallet.insert_adhoc (nano::dev::genesis_key.prv); nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto send2 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio - 1) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio - 1) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); ASSERT_EQ (0, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts)); - node.active.generator.add (nano::genesis_hash, send1->hash ()); + node.active.generator.add (nano::dev::genesis->hash (), send1->hash ()); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 1); ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ())); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code); - node.active.generator.add (nano::genesis_hash, send2->hash ()); + node.active.generator.add (nano::dev::genesis->hash (), send2->hash ()); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing) == 1); ASSERT_EQ (1, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts)); std::this_thread::sleep_for (config.network_params.voting.delay); - node.active.generator.add (nano::genesis_hash, send2->hash ()); + node.active.generator.add (nano::dev::genesis->hash (), send2->hash ()); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 2); } @@ -205,35 +204,35 @@ TEST (vote_spacing, rapid) node_flags.disable_search_pending = true; auto & node = *system.add_node (config, node_flags); auto & wallet = *system.wallet (0); - wallet.insert_adhoc (nano::dev_genesis_key.prv); + wallet.insert_adhoc (nano::dev::genesis_key.prv); nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); auto send2 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio - 1) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio - 1) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send1).code); - node.active.generator.add (nano::genesis_hash, send1->hash ()); + node.active.generator.add (nano::dev::genesis->hash (), send1->hash ()); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 1); ASSERT_FALSE (node.ledger.rollback (node.store.tx_begin_write (), send1->hash ())); ASSERT_EQ (nano::process_result::progress, node.ledger.process (node.store.tx_begin_write (), *send2).code); - node.active.generator.add (nano::genesis_hash, send2->hash ()); + node.active.generator.add (nano::dev::genesis->hash (), send2->hash ()); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_spacing) == 1); ASSERT_TIMELY (3s, 1 == node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts)); std::this_thread::sleep_for (config.network_params.voting.delay); - node.active.generator.add (nano::genesis_hash, send2->hash ()); + node.active.generator.add (nano::dev::genesis->hash (), send2->hash ()); ASSERT_TIMELY (3s, node.stats.count (nano::stat::type::vote_generator, nano::stat::detail::generator_broadcasts) == 2); } diff --git a/nano/core_test/wallet.cpp b/nano/core_test/wallet.cpp index f03c6901a0..cbfc613f3e 100644 --- a/nano/core_test/wallet.cpp +++ b/nano/core_test/wallet.cpp @@ -1,7 +1,7 @@ #include #include #include -#include +#include #include #include @@ -17,8 +17,8 @@ TEST (wallet, no_special_keys_accounts) nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::keypair key1; ASSERT_FALSE (wallet.exists (transaction, key1.pub)); @@ -38,8 +38,8 @@ TEST (wallet, no_key) nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::keypair key1; nano::raw_key prv1; @@ -53,8 +53,8 @@ TEST (wallet, fetch_locked) nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_TRUE (wallet.valid_password (transaction)); nano::keypair key1; ASSERT_EQ (key1.pub, wallet.insert_adhoc (transaction, key1.prv)); @@ -75,8 +75,8 @@ TEST (wallet, retrieval) nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::keypair key1; ASSERT_TRUE (wallet.valid_password (transaction)); @@ -97,8 +97,8 @@ TEST (wallet, empty_iteration) nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); auto i (wallet.begin (transaction)); auto j (wallet.end ()); @@ -111,8 +111,8 @@ TEST (wallet, one_item_iteration) nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::keypair key1; wallet.insert_adhoc (transaction, key1.prv); @@ -137,10 +137,10 @@ TEST (wallet, two_item_iteration) ASSERT_NE (key1.pub, key2.pub); std::unordered_set pubs; std::unordered_set prvs; - nano::kdf kdf; + nano::kdf kdf{ nano::dev::network_params.kdf_work }; { auto transaction (env.tx_begin_write ()); - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); wallet.insert_adhoc (transaction, key1.prv); wallet.insert_adhoc (transaction, key2.prv); @@ -166,43 +166,43 @@ TEST (wallet, insufficient_spend_one) { nano::system system (1); nano::keypair key1; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key1.pub, 500)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 500)); ASSERT_NE (nullptr, block); - ASSERT_EQ (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key1.pub, nano::genesis_amount)); + ASSERT_EQ (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, nano::dev::constants.genesis_amount)); } TEST (wallet, spend_all_one) { nano::system system (1); auto & node1 (*system.nodes[0]); - nano::block_hash latest1 (node1.latest (nano::dev_genesis_key.pub)); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + nano::block_hash latest1 (node1.latest (nano::dev::genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key2; - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, std::numeric_limits::max ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, std::numeric_limits::max ())); nano::account_info info2; { auto transaction (node1.store.tx_begin_read ()); - node1.store.account_get (transaction, nano::dev_genesis_key.pub, info2); + node1.store.account.get (transaction, nano::dev::genesis_key.pub, info2); ASSERT_NE (latest1, info2.head); - auto block (node1.store.block_get (transaction, info2.head)); + auto block (node1.store.block.get (transaction, info2.head)); ASSERT_NE (nullptr, block); ASSERT_EQ (latest1, block->previous ()); } ASSERT_TRUE (info2.balance.is_zero ()); - ASSERT_EQ (0, node1.balance (nano::dev_genesis_key.pub)); + ASSERT_EQ (0, node1.balance (nano::dev::genesis_key.pub)); } TEST (wallet, send_async) { nano::system system (1); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key2; std::thread thread ([&system] () { - ASSERT_TIMELY (10s, system.nodes[0]->balance (nano::dev_genesis_key.pub).is_zero ()); + ASSERT_TIMELY (10s, system.nodes[0]->balance (nano::dev::genesis_key.pub).is_zero ()); }); std::atomic success (false); - system.wallet (0)->send_async (nano::dev_genesis_key.pub, key2.pub, std::numeric_limits::max (), [&success] (std::shared_ptr const & block_a) { ASSERT_NE (nullptr, block_a); success = true; }); + system.wallet (0)->send_async (nano::dev::genesis_key.pub, key2.pub, std::numeric_limits::max (), [&success] (std::shared_ptr const & block_a) { ASSERT_NE (nullptr, block_a); success = true; }); thread.join (); ASSERT_TIMELY (2s, success); } @@ -211,34 +211,34 @@ TEST (wallet, spend) { nano::system system (1); auto & node1 (*system.nodes[0]); - nano::block_hash latest1 (node1.latest (nano::dev_genesis_key.pub)); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + nano::block_hash latest1 (node1.latest (nano::dev::genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key2; // Sending from empty accounts should always be an error. Accounts need to be opened with an open block, not a send block. ASSERT_EQ (nullptr, system.wallet (0)->send_action (0, key2.pub, 0)); - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, std::numeric_limits::max ())); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, std::numeric_limits::max ())); nano::account_info info2; { auto transaction (node1.store.tx_begin_read ()); - node1.store.account_get (transaction, nano::dev_genesis_key.pub, info2); + node1.store.account.get (transaction, nano::dev::genesis_key.pub, info2); ASSERT_NE (latest1, info2.head); - auto block (node1.store.block_get (transaction, info2.head)); + auto block (node1.store.block.get (transaction, info2.head)); ASSERT_NE (nullptr, block); ASSERT_EQ (latest1, block->previous ()); } ASSERT_TRUE (info2.balance.is_zero ()); - ASSERT_EQ (0, node1.balance (nano::dev_genesis_key.pub)); + ASSERT_EQ (0, node1.balance (nano::dev::genesis_key.pub)); } TEST (wallet, change) { nano::system system (1); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key2; - auto block1 (system.nodes[0]->rep_block (nano::dev_genesis_key.pub)); + auto block1 (system.nodes[0]->rep_block (nano::dev::genesis_key.pub)); ASSERT_FALSE (block1.is_zero ()); - ASSERT_NE (nullptr, system.wallet (0)->change_action (nano::dev_genesis_key.pub, key2.pub)); - auto block2 (system.nodes[0]->rep_block (nano::dev_genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->change_action (nano::dev::genesis_key.pub, key2.pub)); + auto block2 (system.nodes[0]->rep_block (nano::dev::genesis_key.pub)); ASSERT_FALSE (block2.is_zero ()); ASSERT_NE (block1, block2); } @@ -246,20 +246,20 @@ TEST (wallet, change) TEST (wallet, partial_spend) { nano::system system (1); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key2; - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, 500)); - ASSERT_EQ (std::numeric_limits::max () - 500, system.nodes[0]->balance (nano::dev_genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 500)); + ASSERT_EQ (std::numeric_limits::max () - 500, system.nodes[0]->balance (nano::dev::genesis_key.pub)); } TEST (wallet, spend_no_previous) { nano::system system (1); { - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto transaction (system.nodes[0]->store.tx_begin_read ()); nano::account_info info1; - ASSERT_FALSE (system.nodes[0]->store.account_get (transaction, nano::dev_genesis_key.pub, info1)); + ASSERT_FALSE (system.nodes[0]->store.account.get (transaction, nano::dev::genesis_key.pub, info1)); for (auto i (0); i < 50; ++i) { nano::keypair key; @@ -267,8 +267,8 @@ TEST (wallet, spend_no_previous) } } nano::keypair key2; - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, 500)); - ASSERT_EQ (std::numeric_limits::max () - 500, system.nodes[0]->balance (nano::dev_genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, 500)); + ASSERT_EQ (std::numeric_limits::max () - 500, system.nodes[0]->balance (nano::dev::genesis_key.pub)); } TEST (wallet, find_none) @@ -277,8 +277,8 @@ TEST (wallet, find_none) nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::account account (1000); ASSERT_EQ (wallet.end (), wallet.find (transaction, account)); @@ -290,8 +290,8 @@ TEST (wallet, find_existing) nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::keypair key1; ASSERT_FALSE (wallet.exists (transaction, key1.pub)); @@ -309,8 +309,8 @@ TEST (wallet, rekey) nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::raw_key password; wallet.password.value (password); @@ -335,15 +335,15 @@ TEST (wallet, rekey) TEST (account, encode_zero) { - nano::account number0 (0); + nano::account number0{}; std::string str0; number0.encode_account (str0); /* * Handle different lengths for "ban_" prefixed and "nano_" prefixed accounts */ - ASSERT_EQ ((str0.front () == 'x') ? 64 : 65, str0.size ()); - ASSERT_EQ (65, str0.size ()); + ASSERT_EQ ((str0.front () == 'b') ? 64 : 65, str0.size ()); + ASSERT_EQ (64, str0.size ()); nano::account number1; ASSERT_FALSE (number1.decode_account (str0)); ASSERT_EQ (number0, number1); @@ -359,7 +359,7 @@ TEST (account, encode_all) /* * Handle different lengths for "ban_" prefixed and "nano_" prefixed accounts */ - ASSERT_EQ ((str0.front () == 'x') ? 64 : 65, str0.size ()); + ASSERT_EQ ((str0.front () == 'b') ? 64 : 65, str0.size ()); nano::account number1; ASSERT_FALSE (number1.decode_account (str0)); ASSERT_EQ (number0, number1); @@ -367,7 +367,7 @@ TEST (account, encode_all) TEST (account, encode_fail) { - nano::account number0 (0); + nano::account number0{}; std::string str0; number0.encode_account (str0); str0[16] ^= 1; @@ -381,8 +381,8 @@ TEST (wallet, hash_password) nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); nano::raw_key hash1; wallet.derive_key (hash1, transaction, ""); @@ -430,27 +430,27 @@ TEST (wallet, reopen_default_password) nano::mdb_env env (init, nano::unique_path ()); auto transaction (env.tx_begin_write ()); ASSERT_FALSE (init); - nano::kdf kdf; + nano::kdf kdf{ nano::dev::network_params.kdf_work }; { - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); ASSERT_TRUE (wallet.valid_password (transaction)); } { bool init; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); ASSERT_TRUE (wallet.valid_password (transaction)); } { - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); wallet.rekey (transaction, ""); ASSERT_TRUE (wallet.valid_password (transaction)); } { bool init; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (init); ASSERT_FALSE (wallet.valid_password (transaction)); wallet.attempt_password (transaction, " "); @@ -466,11 +466,11 @@ TEST (wallet, representative) nano::mdb_env env (error, nano::unique_path ()); ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet (error, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet (error, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (error); ASSERT_FALSE (wallet.is_representative (transaction)); - ASSERT_EQ (nano::genesis_account, wallet.representative (transaction)); + ASSERT_EQ (nano::dev::genesis->account (), wallet.representative (transaction)); ASSERT_FALSE (wallet.is_representative (transaction)); nano::keypair key; wallet.representative_set (transaction, key.pub); @@ -487,12 +487,12 @@ TEST (wallet, serialize_json_empty) nano::mdb_env env (error, nano::unique_path ()); ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet1 (error, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (error); std::string serialized; wallet1.serialize_json (transaction, serialized); - nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1", serialized); + nano::wallet_store wallet2 (error, kdf, transaction, nano::dev::genesis->account (), 1, "1", serialized); ASSERT_FALSE (error); nano::raw_key password1; nano::raw_key password2; @@ -512,14 +512,14 @@ TEST (wallet, serialize_json_one) nano::mdb_env env (error, nano::unique_path ()); ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet1 (error, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (error); nano::keypair key; wallet1.insert_adhoc (transaction, key.prv); std::string serialized; wallet1.serialize_json (transaction, serialized); - nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1", serialized); + nano::wallet_store wallet2 (error, kdf, transaction, nano::dev::genesis->account (), 1, "1", serialized); ASSERT_FALSE (error); nano::raw_key password1; nano::raw_key password2; @@ -541,15 +541,15 @@ TEST (wallet, serialize_json_password) nano::mdb_env env (error, nano::unique_path ()); ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet1 (error, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (error); nano::keypair key; wallet1.rekey (transaction, "password"); wallet1.insert_adhoc (transaction, key.prv); std::string serialized; wallet1.serialize_json (transaction, serialized); - nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1", serialized); + nano::wallet_store wallet2 (error, kdf, transaction, nano::dev::genesis->account (), 1, "1", serialized); ASSERT_FALSE (error); ASSERT_FALSE (wallet2.valid_password (transaction)); ASSERT_FALSE (wallet2.attempt_password (transaction, "password")); @@ -574,12 +574,12 @@ TEST (wallet_store, move) nano::mdb_env env (error, nano::unique_path ()); ASSERT_FALSE (error); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet1 (error, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet1 (error, kdf, transaction, nano::dev::genesis->account (), 1, "0"); ASSERT_FALSE (error); nano::keypair key1; wallet1.insert_adhoc (transaction, key1.prv); - nano::wallet_store wallet2 (error, kdf, transaction, nano::genesis_account, 1, "1"); + nano::wallet_store wallet2 (error, kdf, transaction, nano::dev::genesis->account (), 1, "1"); ASSERT_FALSE (error); nano::keypair key2; wallet2.insert_adhoc (transaction, key2.prv); @@ -635,17 +635,17 @@ TEST (wallet, work) { nano::system system (1); auto wallet (system.wallet (0)); - wallet->insert_adhoc (nano::dev_genesis_key.prv); - nano::genesis genesis; + wallet->insert_adhoc (nano::dev::genesis_key.prv); + wallet->insert_adhoc (nano::dev::genesis_key.prv); auto done (false); system.deadline_set (20s); while (!done) { auto transaction (system.wallet (0)->wallets.tx_begin_read ()); uint64_t work (0); - if (!wallet->store.work_get (transaction, nano::dev_genesis_key.pub, work)) + if (!wallet->store.work_get (transaction, nano::dev::genesis_key.pub, work)) { - done = nano::work_difficulty (genesis.open->work_version (), genesis.hash (), work) >= system.nodes[0]->default_difficulty (genesis.open->work_version ()); + done = nano::dev::network_params.work.difficulty (nano::dev::genesis->work_version (), nano::dev::genesis->hash (), work) >= system.nodes[0]->default_difficulty (nano::dev::genesis->work_version ()); } ASSERT_NO_ERROR (system.poll ()); } @@ -656,18 +656,18 @@ TEST (wallet, work_generate) nano::system system (1); auto & node1 (*system.nodes[0]); auto wallet (system.wallet (0)); - nano::uint128_t amount1 (node1.balance (nano::dev_genesis_key.pub)); + nano::uint128_t amount1 (node1.balance (nano::dev::genesis_key.pub)); uint64_t work1; - wallet->insert_adhoc (nano::dev_genesis_key.prv); + wallet->insert_adhoc (nano::dev::genesis_key.prv); nano::account account1; { auto transaction (node1.wallets.tx_begin_read ()); account1 = system.account (transaction, 0); } nano::keypair key; - auto block (wallet->send_action (nano::dev_genesis_key.pub, key.pub, 100)); + auto block (wallet->send_action (nano::dev::genesis_key.pub, key.pub, 100)); auto transaction (node1.store.tx_begin_read ()); - ASSERT_TIMELY (10s, node1.ledger.account_balance (transaction, nano::dev_genesis_key.pub) != amount1); + ASSERT_TIMELY (10s, node1.ledger.account_balance (transaction, nano::dev::genesis_key.pub) != amount1); system.deadline_set (10s); auto again (true); while (again) @@ -675,7 +675,7 @@ TEST (wallet, work_generate) ASSERT_NO_ERROR (system.poll ()); auto block_transaction (node1.store.tx_begin_read ()); auto transaction (system.wallet (0)->wallets.tx_begin_read ()); - again = wallet->store.work_get (transaction, account1, work1) || nano::work_difficulty (block->work_version (), node1.ledger.latest_root (block_transaction, account1), work1) < node1.default_difficulty (block->work_version ()); + again = wallet->store.work_get (transaction, account1, work1) || nano::dev::network_params.work.difficulty (block->work_version (), node1.ledger.latest_root (block_transaction, account1), work1) < node1.default_difficulty (block->work_version ()); } } @@ -685,18 +685,18 @@ TEST (wallet, work_cache_delayed) auto & node1 (*system.nodes[0]); auto wallet (system.wallet (0)); uint64_t work1; - wallet->insert_adhoc (nano::dev_genesis_key.prv); + wallet->insert_adhoc (nano::dev::genesis_key.prv); nano::account account1; { auto transaction (node1.wallets.tx_begin_read ()); account1 = system.account (transaction, 0); } nano::keypair key; - auto block1 (wallet->send_action (nano::dev_genesis_key.pub, key.pub, 100)); - ASSERT_EQ (block1->hash (), node1.latest (nano::dev_genesis_key.pub)); - auto block2 (wallet->send_action (nano::dev_genesis_key.pub, key.pub, 100)); - ASSERT_EQ (block2->hash (), node1.latest (nano::dev_genesis_key.pub)); - ASSERT_EQ (block2->hash (), node1.wallets.delayed_work->operator[] (nano::dev_genesis_key.pub)); + auto block1 (wallet->send_action (nano::dev::genesis_key.pub, key.pub, 100)); + ASSERT_EQ (block1->hash (), node1.latest (nano::dev::genesis_key.pub)); + auto block2 (wallet->send_action (nano::dev::genesis_key.pub, key.pub, 100)); + ASSERT_EQ (block2->hash (), node1.latest (nano::dev::genesis_key.pub)); + ASSERT_EQ (block2->hash (), node1.wallets.delayed_work->operator[] (nano::dev::genesis_key.pub)); auto threshold (node1.default_difficulty (nano::work_version::work_1)); auto again (true); system.deadline_set (10s); @@ -705,10 +705,10 @@ TEST (wallet, work_cache_delayed) ASSERT_NO_ERROR (system.poll ()); if (!wallet->store.work_get (node1.wallets.tx_begin_read (), account1, work1)) { - again = nano::work_difficulty (nano::work_version::work_1, block2->hash (), work1) < threshold; + again = nano::dev::network_params.work.difficulty (nano::work_version::work_1, block2->hash (), work1) < threshold; } } - ASSERT_GE (nano::work_difficulty (nano::work_version::work_1, block2->hash (), work1), threshold); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, block2->hash (), work1), threshold); } TEST (wallet, insert_locked) @@ -732,8 +732,8 @@ TEST (wallet, deterministic_keys) nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); auto key1 = wallet.deterministic_key (transaction, 0); auto key2 = wallet.deterministic_key (transaction, 0); ASSERT_EQ (key1, key2); @@ -775,8 +775,8 @@ TEST (wallet, reseed) nano::mdb_env env (init, nano::unique_path ()); ASSERT_FALSE (init); auto transaction (env.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store wallet (init, kdf, transaction, nano::genesis_account, 1, "0"); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store wallet (init, kdf, transaction, nano::dev::genesis->account (), 1, "0"); nano::raw_key seed1; seed1 = 1; nano::raw_key seed2; @@ -817,27 +817,27 @@ TEST (wallet, insert_deterministic_locked) TEST (wallet, no_work) { nano::system system (1); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv, false); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv, false); nano::keypair key2; - auto block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, std::numeric_limits::max (), false)); + auto block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, std::numeric_limits::max (), false)); ASSERT_NE (nullptr, block); ASSERT_NE (0, block->block_work ()); - ASSERT_GE (block->difficulty (), nano::work_threshold (block->work_version (), block->sideband ().details)); + ASSERT_GE (nano::dev::network_params.work.difficulty (*block), nano::dev::network_params.work.threshold (block->work_version (), block->sideband ().details)); auto transaction (system.wallet (0)->wallets.tx_begin_read ()); uint64_t cached_work (0); - system.wallet (0)->store.work_get (transaction, nano::dev_genesis_key.pub, cached_work); + system.wallet (0)->store.work_get (transaction, nano::dev::genesis_key.pub, cached_work); ASSERT_EQ (0, cached_work); } TEST (wallet, send_race) { nano::system system (1); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key2; for (auto i (1); i < 60; ++i) { - ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev_genesis_key.pub, key2.pub, nano::MBAN_ratio)); - ASSERT_EQ (nano::genesis_amount - nano::MBAN_ratio * i, system.nodes[0]->balance (nano::dev_genesis_key.pub)); + ASSERT_NE (nullptr, system.wallet (0)->send_action (nano::dev::genesis_key.pub, key2.pub, nano::MBAN_ratio)); + ASSERT_EQ (nano::dev::constants.genesis_amount - nano::MBAN_ratio * i, system.nodes[0]->balance (nano::dev::genesis_key.pub)); } } @@ -950,8 +950,8 @@ TEST (wallet, change_seed) uint32_t index (4); auto prv = nano::deterministic_key (seed1, index); pub = nano::pub_key (prv); - wallet->insert_adhoc (nano::dev_genesis_key.prv, false); - auto block (wallet->send_action (nano::dev_genesis_key.pub, pub, 100)); + wallet->insert_adhoc (nano::dev::genesis_key.prv, false); + auto block (wallet->send_action (nano::dev::genesis_key.pub, pub, 100)); ASSERT_NE (nullptr, block); system.nodes[0]->block_processor.flush (); { @@ -984,8 +984,8 @@ TEST (wallet, deterministic_restore) auto prv = nano::deterministic_key (seed1, index); pub = nano::pub_key (prv); } - wallet->insert_adhoc (nano::dev_genesis_key.prv, false); - auto block (wallet->send_action (nano::dev_genesis_key.pub, pub, 100)); + wallet->insert_adhoc (nano::dev::genesis_key.prv, false); + auto block (wallet->send_action (nano::dev::genesis_key.pub, pub, 100)); ASSERT_NE (nullptr, block); system.nodes[0]->block_processor.flush (); { @@ -1006,7 +1006,7 @@ TEST (wallet, epoch_2_validation) ASSERT_NE (nullptr, system.upgrade_genesis_epoch (node, nano::epoch::epoch_1)); ASSERT_NE (nullptr, system.upgrade_genesis_epoch (node, nano::epoch::epoch_2)); - wallet.insert_adhoc (nano::dev_genesis_key.prv, false); + wallet.insert_adhoc (nano::dev::genesis_key.prv, false); // Test send and receive blocks // An epoch 2 receive block should be generated with lower difficulty with high probability @@ -1015,16 +1015,16 @@ TEST (wallet, epoch_2_validation) auto amount = node.config.receive_minimum.number (); while (++tries < max_tries) { - auto send = wallet.send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, amount, 1); + auto send = wallet.send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, amount, 1); ASSERT_NE (nullptr, send); ASSERT_EQ (nano::epoch::epoch_2, send->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_0, send->sideband ().source_epoch); // Not used for send state blocks - auto receive = wallet.receive_action (send->hash (), nano::dev_genesis_key.pub, amount, send->link ().as_account (), 1); + auto receive = wallet.receive_action (send->hash (), nano::dev::genesis_key.pub, amount, send->link ().as_account (), 1); ASSERT_NE (nullptr, receive); - if (receive->difficulty () < node.network_params.network.publish_thresholds.base) + if (nano::dev::network_params.work.difficulty (*receive) < node.network_params.work.base) { - ASSERT_GE (receive->difficulty (), node.network_params.network.publish_thresholds.epoch_2_receive); + ASSERT_GE (nano::dev::network_params.work.difficulty (*receive), node.network_params.work.epoch_2_receive); ASSERT_EQ (nano::epoch::epoch_2, receive->sideband ().details.epoch); ASSERT_EQ (nano::epoch::epoch_2, receive->sideband ().source_epoch); break; @@ -1033,7 +1033,7 @@ TEST (wallet, epoch_2_validation) ASSERT_LT (tries, max_tries); // Test a change block - ASSERT_NE (nullptr, wallet.change_action (nano::dev_genesis_key.pub, nano::keypair ().pub, 1)); + ASSERT_NE (nullptr, wallet.change_action (nano::dev::genesis_key.pub, nano::keypair ().pub, 1)); } // Receiving from an upgraded account uses the lower threshold and upgrades the receiving account @@ -1057,27 +1057,27 @@ TEST (wallet, epoch_2_receive_propagation) nano::state_block_builder builder; // Send and open the account - wallet.insert_adhoc (nano::dev_genesis_key.prv, false); + wallet.insert_adhoc (nano::dev::genesis_key.prv, false); wallet.insert_adhoc (key.prv, false); auto amount = node.config.receive_minimum.number (); - auto send1 = wallet.send_action (nano::dev_genesis_key.pub, key.pub, amount, 1); + auto send1 = wallet.send_action (nano::dev::genesis_key.pub, key.pub, amount, 1); ASSERT_NE (nullptr, send1); - ASSERT_NE (nullptr, wallet.receive_action (send1->hash (), nano::dev_genesis_key.pub, amount, send1->link ().as_account (), 1)); + ASSERT_NE (nullptr, wallet.receive_action (send1->hash (), nano::dev::genesis_key.pub, amount, send1->link ().as_account (), 1)); // Upgrade the genesis account to epoch 2 auto epoch2 = system.upgrade_genesis_epoch (node, nano::epoch::epoch_2); ASSERT_NE (nullptr, epoch2); // Send a block - auto send2 = wallet.send_action (nano::dev_genesis_key.pub, key.pub, amount, 1); + auto send2 = wallet.send_action (nano::dev::genesis_key.pub, key.pub, amount, 1); ASSERT_NE (nullptr, send2); auto receive2 = wallet.receive_action (send2->hash (), key.pub, amount, send2->link ().as_account (), 1); ASSERT_NE (nullptr, receive2); - if (receive2->difficulty () < node.network_params.network.publish_thresholds.base) + if (nano::dev::network_params.work.difficulty (*receive2) < node.network_params.work.base) { - ASSERT_GE (receive2->difficulty (), node.network_params.network.publish_thresholds.epoch_2_receive); - ASSERT_EQ (nano::epoch::epoch_2, node.store.block_version (node.store.tx_begin_read (), receive2->hash ())); + ASSERT_GE (nano::dev::network_params.work.difficulty (*receive2), node.network_params.work.epoch_2_receive); + ASSERT_EQ (nano::epoch::epoch_2, node.store.block.version (node.store.tx_begin_read (), receive2->hash ())); ASSERT_EQ (nano::epoch::epoch_2, receive2->sideband ().source_epoch); break; } @@ -1107,22 +1107,22 @@ TEST (wallet, epoch_2_receive_unopened) nano::state_block_builder builder; // Send - wallet.insert_adhoc (nano::dev_genesis_key.prv, false); + wallet.insert_adhoc (nano::dev::genesis_key.prv, false); auto amount = node.config.receive_minimum.number (); - auto send1 = wallet.send_action (nano::dev_genesis_key.pub, key.pub, amount, 1); + auto send1 = wallet.send_action (nano::dev::genesis_key.pub, key.pub, amount, 1); // Upgrade unopened account to epoch_2 - auto epoch2_unopened = nano::state_block (key.pub, 0, 0, 0, node.network_params.ledger.epochs.link (nano::epoch::epoch_2), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (key.pub, node.network_params.network.publish_thresholds.epoch_2)); + auto epoch2_unopened = nano::state_block (key.pub, 0, 0, 0, node.network_params.ledger.epochs.link (nano::epoch::epoch_2), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (key.pub, node.network_params.work.epoch_2)); ASSERT_EQ (nano::process_result::progress, node.process (epoch2_unopened).code); wallet.insert_adhoc (key.prv, false); auto receive1 = wallet.receive_action (send1->hash (), key.pub, amount, send1->link ().as_account (), 1); ASSERT_NE (nullptr, receive1); - if (receive1->difficulty () < node.network_params.network.publish_thresholds.base) + if (nano::dev::network_params.work.difficulty (*receive1) < node.network_params.work.base) { - ASSERT_GE (receive1->difficulty (), node.network_params.network.publish_thresholds.epoch_2_receive); - ASSERT_EQ (nano::epoch::epoch_2, node.store.block_version (node.store.tx_begin_read (), receive1->hash ())); + ASSERT_GE (nano::dev::network_params.work.difficulty (*receive1), node.network_params.work.epoch_2_receive); + ASSERT_EQ (nano::epoch::epoch_2, node.store.block.version (node.store.tx_begin_read (), receive1->hash ())); ASSERT_EQ (nano::epoch::epoch_1, receive1->sideband ().source_epoch); break; } @@ -1134,7 +1134,7 @@ TEST (wallet, foreach_representative_deadlock) { nano::system system (1); auto & node (*system.nodes[0]); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); node.wallets.compute_reps (); ASSERT_EQ (1, node.wallets.reps ().voting); node.wallets.foreach_representative ([&node] (nano::public_key const & pub, nano::raw_key const & prv) { @@ -1160,16 +1160,16 @@ TEST (wallet, search_pending) auto & node (*system.add_node (config, flags)); auto & wallet (*system.wallet (0)); - wallet.insert_adhoc (nano::dev_genesis_key.prv); + wallet.insert_adhoc (nano::dev::genesis_key.prv); nano::block_builder builder; auto send = builder.state () - .account (nano::genesis_account) - .previous (nano::genesis_hash) - .representative (nano::genesis_account) - .balance (nano::genesis_amount - node.config.receive_minimum.number ()) - .link (nano::genesis_account) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - node.config.receive_minimum.number ()) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::process_result::progress, node.process (*send).code); @@ -1180,7 +1180,7 @@ TEST (wallet, search_pending) ASSERT_NE (nullptr, election); // Erase the key so the confirmation does not trigger an automatic receive - wallet.store.erase (node.wallets.tx_begin_write (), nano::genesis_account); + wallet.store.erase (node.wallets.tx_begin_write (), nano::dev::genesis->account ()); // Now confirm the election election->force_confirm (); @@ -1188,13 +1188,13 @@ TEST (wallet, search_pending) ASSERT_TIMELY (5s, node.block_confirmed (send->hash ()) && node.active.empty ()); // Re-insert the key - wallet.insert_adhoc (nano::dev_genesis_key.prv); + wallet.insert_adhoc (nano::dev::genesis_key.prv); // Pending search should create the receive block ASSERT_EQ (2, node.ledger.cache.block_count); ASSERT_FALSE (wallet.search_pending (wallet.wallets.tx_begin_read ())); - ASSERT_TIMELY (3s, node.balance (nano::genesis_account) == nano::genesis_amount); - auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::genesis_account); + ASSERT_TIMELY (3s, node.balance (nano::dev::genesis->account ()) == nano::dev::constants.genesis_amount); + auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::dev::genesis->account ()); auto receive = node.block (receive_hash); ASSERT_NE (nullptr, receive); ASSERT_EQ (receive->sideband ().height, 3); @@ -1219,10 +1219,10 @@ TEST (wallet, receive_pruned) nano::state_block_builder builder; // Send - wallet1.insert_adhoc (nano::dev_genesis_key.prv, false); + wallet1.insert_adhoc (nano::dev::genesis_key.prv, false); auto amount = node2.config.receive_minimum.number (); - auto send1 = wallet1.send_action (nano::dev_genesis_key.pub, key.pub, amount, 1); - auto send2 = wallet1.send_action (nano::dev_genesis_key.pub, key.pub, 1, 1); + auto send1 = wallet1.send_action (nano::dev::genesis_key.pub, key.pub, amount, 1); + auto send2 = wallet1.send_action (nano::dev::genesis_key.pub, key.pub, 1, 1); // Pruning ASSERT_TIMELY (5s, node2.ledger.cache.cemented_count == 3); @@ -1232,7 +1232,7 @@ TEST (wallet, receive_pruned) } ASSERT_EQ (1, node2.ledger.cache.pruned_count); ASSERT_TRUE (node2.ledger.block_or_pruned_exists (send1->hash ())); - ASSERT_FALSE (node2.store.block_exists (node2.store.tx_begin_read (), send1->hash ())); + ASSERT_FALSE (node2.store.block.exists (node2.store.tx_begin_read (), send1->hash ())); wallet2.insert_adhoc (key.prv, false); diff --git a/nano/core_test/wallets.cpp b/nano/core_test/wallets.cpp index 21871a050d..2929e15bc2 100644 --- a/nano/core_test/wallets.cpp +++ b/nano/core_test/wallets.cpp @@ -1,5 +1,5 @@ -#include #include +#include #include #include @@ -73,30 +73,6 @@ TEST (wallets, remove) } } -// Keeps breaking whenever we add new DBs -TEST (wallets, DISABLED_wallet_create_max) -{ - nano::system system (1); - bool error (false); - nano::wallets wallets (error, *system.nodes[0]); - const int nonWalletDbs = 19; - for (int i = 0; i < system.nodes[0]->config.deprecated_lmdb_max_dbs - nonWalletDbs; i++) - { - auto wallet_id = nano::random_wallet_id (); - auto wallet = wallets.create (wallet_id); - auto existing = wallets.items.find (wallet_id); - ASSERT_TRUE (existing != wallets.items.end ()); - nano::raw_key seed; - seed = 0; - auto transaction (system.nodes[0]->store.tx_begin_write ()); - existing->second->store.seed_set (transaction, seed); - } - auto wallet_id = nano::random_wallet_id (); - wallets.create (wallet_id); - auto existing = wallets.items.find (wallet_id); - ASSERT_TRUE (existing == wallets.items.end ()); -} - TEST (wallets, reload) { nano::system system (1); @@ -121,13 +97,12 @@ TEST (wallets, vote_minimum) auto & node1 (*system.nodes[0]); nano::keypair key1; nano::keypair key2; - nano::genesis genesis; - nano::state_block send1 (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, std::numeric_limits::max () - node1.config.vote_minimum.number (), key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (genesis.hash ())); + nano::state_block send1 (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, std::numeric_limits::max () - node1.config.vote_minimum.number (), key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, node1.process (send1).code); nano::state_block open1 (key1.pub, 0, key1.pub, node1.config.vote_minimum.number (), send1.hash (), key1.prv, key1.pub, *system.work.generate (key1.pub)); ASSERT_EQ (nano::process_result::progress, node1.process (open1).code); // send2 with amount vote_minimum - 1 (not voting representative) - nano::state_block send2 (nano::dev_genesis_key.pub, send1.hash (), nano::dev_genesis_key.pub, std::numeric_limits::max () - 2 * node1.config.vote_minimum.number () + 1, key2.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1.hash ())); + nano::state_block send2 (nano::dev::genesis_key.pub, send1.hash (), nano::dev::genesis_key.pub, std::numeric_limits::max () - 2 * node1.config.vote_minimum.number () + 1, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, node1.process (send2).code); nano::state_block open2 (key2.pub, 0, key2.pub, node1.config.vote_minimum.number () - 1, send2.hash (), key2.prv, key2.pub, *system.work.generate (key2.pub)); ASSERT_EQ (nano::process_result::progress, node1.process (open2).code); @@ -135,7 +110,7 @@ TEST (wallets, vote_minimum) nano::unique_lock representatives_lk (wallet->representatives_mutex); ASSERT_EQ (0, wallet->representatives.size ()); representatives_lk.unlock (); - wallet->insert_adhoc (nano::dev_genesis_key.prv); + wallet->insert_adhoc (nano::dev::genesis_key.prv); wallet->insert_adhoc (key1.prv); wallet->insert_adhoc (key2.prv); node1.wallets.compute_reps (); @@ -187,16 +162,16 @@ TEST (wallets, search_pending) auto wallet_id = wallets.begin ()->first; auto wallet = wallets.begin ()->second; - wallet->insert_adhoc (nano::dev_genesis_key.prv); + wallet->insert_adhoc (nano::dev::genesis_key.prv); nano::block_builder builder; auto send = builder.state () - .account (nano::genesis_account) - .previous (nano::genesis_hash) - .representative (nano::genesis_account) - .balance (nano::genesis_amount - node.config.receive_minimum.number ()) - .link (nano::genesis_account) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .account (nano::dev::genesis->account ()) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis->account ()) + .balance (nano::dev::constants.genesis_amount - node.config.receive_minimum.number ()) + .link (nano::dev::genesis->account ()) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::process_result::progress, node.process (*send).code); @@ -214,7 +189,7 @@ TEST (wallets, search_pending) ASSERT_NE (nullptr, election); // Erase the key so the confirmation does not trigger an automatic receive - wallet->store.erase (node.wallets.tx_begin_write (), nano::genesis_account); + wallet->store.erase (node.wallets.tx_begin_write (), nano::dev::genesis->account ()); // Now confirm the election election->force_confirm (); @@ -222,7 +197,7 @@ TEST (wallets, search_pending) ASSERT_TIMELY (5s, node.block_confirmed (send->hash ()) && node.active.empty ()); // Re-insert the key - wallet->insert_adhoc (nano::dev_genesis_key.prv); + wallet->insert_adhoc (nano::dev::genesis_key.prv); // Pending search should create the receive block ASSERT_EQ (2, node.ledger.cache.block_count); @@ -234,8 +209,8 @@ TEST (wallets, search_pending) { node.wallets.search_pending (wallet_id); } - ASSERT_TIMELY (3s, node.balance (nano::genesis_account) == nano::genesis_amount); - auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::genesis_account); + ASSERT_TIMELY (3s, node.balance (nano::dev::genesis->account ()) == nano::dev::constants.genesis_amount); + auto receive_hash = node.ledger.latest (node.store.tx_begin_read (), nano::dev::genesis->account ()); auto receive = node.block (receive_hash); ASSERT_NE (nullptr, receive); ASSERT_EQ (receive->sideband ().height, 3); diff --git a/nano/core_test/websocket.cpp b/nano/core_test/websocket.cpp index 203e73a8dd..db1bd05c60 100644 --- a/nano/core_test/websocket.cpp +++ b/nano/core_test/websocket.cpp @@ -1,6 +1,6 @@ #include -#include #include +#include #include #include @@ -82,14 +82,14 @@ TEST (websocket, confirmation) ASSERT_TIMELY (5s, ack_ready); nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto balance = nano::genesis_amount; + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto balance = nano::dev::constants.genesis_amount; auto send_amount = node1->online_reps.delta () + 1; // Quick-confirm a block, legacy blocks should work without filtering { - nano::block_hash previous (node1->latest (nano::dev_genesis_key.pub)); + nano::block_hash previous (node1->latest (nano::dev::genesis_key.pub)); balance -= send_amount; - auto send (std::make_shared (previous, key.pub, balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (previous))); + auto send (std::make_shared (previous, key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous))); node1->process_active (send); } @@ -98,15 +98,15 @@ TEST (websocket, confirmation) // Quick confirm a state block { nano::state_block_builder builder; - nano::block_hash previous (node1->latest (nano::dev_genesis_key.pub)); + nano::block_hash previous (node1->latest (nano::dev::genesis_key.pub)); balance -= send_amount; auto send = builder - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (previous) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (balance) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) .build_shared (); @@ -140,11 +140,10 @@ TEST (websocket, stopped_election) // Create election, then erase it, causing a websocket message to be emitted nano::keypair key1; - nano::genesis genesis; - auto send1 (std::make_shared (genesis.hash (), key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (genesis.hash ()))); - nano::publish publish1 (send1); + auto send1 (std::make_shared (nano::dev::genesis->hash (), key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); + nano::publish publish1{ nano::dev::network_params.network, send1 }; auto channel1 (node1->network.udp_channels.create (node1->network.endpoint ())); - node1->network.process_message (publish1, channel1); + node1->network.inbound (publish1, channel1); node1->block_processor.flush (); ASSERT_TIMELY (1s, node1->active.election (send1->qualified_root ())); node1->active.erase (*send1); @@ -184,21 +183,21 @@ TEST (websocket, confirmation_options) ASSERT_TIMELY (5s, ack_ready); // Confirm a state block for an in-wallet account - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key; - auto balance = nano::genesis_amount; + auto balance = nano::dev::constants.genesis_amount; auto send_amount = node1->online_reps.delta () + 1; - nano::block_hash previous (node1->latest (nano::dev_genesis_key.pub)); + nano::block_hash previous (node1->latest (nano::dev::genesis_key.pub)); { balance -= send_amount; nano::state_block_builder builder; auto send = builder - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (previous) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (balance) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) .build_shared (); @@ -226,12 +225,12 @@ TEST (websocket, confirmation_options) balance -= send_amount; nano::state_block_builder builder; auto send = builder - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (previous) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (balance) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) .build_shared (); @@ -288,7 +287,7 @@ TEST (websocket, confirmation_options) // When filtering options are enabled, legacy blocks are always filtered { balance -= send_amount; - auto send (std::make_shared (previous, key.pub, balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (previous))); + auto send (std::make_shared (previous, key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous))); node1->process_active (send); previous = send->hash (); } @@ -318,21 +317,21 @@ TEST (websocket, confirmation_options_votes) ASSERT_TIMELY (10s, ack_ready); // Confirm a state block for an in-wallet account - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key; - auto balance = nano::genesis_amount; + auto balance = nano::dev::constants.genesis_amount; auto send_amount = node1->config.online_weight_minimum.number () + 1; - nano::block_hash previous (node1->latest (nano::dev_genesis_key.pub)); + nano::block_hash previous (node1->latest (nano::dev::genesis_key.pub)); { nano::state_block_builder builder; balance -= send_amount; auto send = builder - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (previous) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (balance) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) .build_shared (); @@ -368,13 +367,13 @@ TEST (websocket, confirmation_options_votes) for (auto & vote : votes_l.get ()) { std::string representative (vote.second.get ("representative")); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), representative); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), representative); std::string timestamp (vote.second.get ("timestamp")); ASSERT_NE ("0", timestamp); std::string hash (vote.second.get ("hash")); - ASSERT_EQ (node1->latest (nano::dev_genesis_key.pub).to_string (), hash); + ASSERT_EQ (node1->latest (nano::dev::genesis_key.pub).to_string (), hash); std::string weight (vote.second.get ("weight")); - ASSERT_EQ (node1->balance (nano::dev_genesis_key.pub).convert_to (), weight); + ASSERT_EQ (node1->balance (nano::dev::genesis_key.pub).convert_to (), weight); } } catch (std::runtime_error const & ex) @@ -401,14 +400,14 @@ TEST (websocket, confirmation_options_update) client.await_ack (); EXPECT_EQ (1, node1->websocket_server->subscriber_count (nano::websocket::topic::confirmation)); // Now update filter with an account and wait for a response - std::string add_message = boost::str (boost::format (R"json({"action": "update", "topic": "confirmation", "ack": "true", "options": {"accounts_add": ["%1%"]}})json") % nano::dev_genesis_key.pub.to_account ()); + std::string add_message = boost::str (boost::format (R"json({"action": "update", "topic": "confirmation", "ack": "true", "options": {"accounts_add": ["%1%"]}})json") % nano::dev::genesis_key.pub.to_account ()); client.send_message (add_message); client.await_ack (); EXPECT_EQ (1, node1->websocket_server->subscriber_count (nano::websocket::topic::confirmation)); added = true; EXPECT_TRUE (client.get_response ()); // Update the filter again, removing the account - std::string delete_message = boost::str (boost::format (R"json({"action": "update", "topic": "confirmation", "ack": "true", "options": {"accounts_del": ["%1%"]}})json") % nano::dev_genesis_key.pub.to_account ()); + std::string delete_message = boost::str (boost::format (R"json({"action": "update", "topic": "confirmation", "ack": "true", "options": {"accounts_del": ["%1%"]}})json") % nano::dev::genesis_key.pub.to_account ()); client.send_message (delete_message); client.await_ack (); EXPECT_EQ (1, node1->websocket_server->subscriber_count (nano::websocket::topic::confirmation)); @@ -421,18 +420,17 @@ TEST (websocket, confirmation_options_update) ASSERT_TIMELY (5s, added); // Confirm a block - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - nano::genesis genesis; + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key; nano::state_block_builder builder; - auto previous (node1->latest (nano::dev_genesis_key.pub)); + auto previous (node1->latest (nano::dev::genesis_key.pub)); auto send = builder - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (previous) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - nano::MBAN_ratio) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - nano::MBAN_ratio) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) .build_shared (); @@ -445,12 +443,12 @@ TEST (websocket, confirmation_options_update) previous = send->hash (); auto send2 = builder .make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (previous) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 2 * nano::MBAN_ratio) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) .build_shared (); @@ -484,15 +482,15 @@ TEST (websocket, vote) // Quick-confirm a block nano::keypair key; nano::state_block_builder builder; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - nano::block_hash previous (node1->latest (nano::dev_genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + nano::block_hash previous (node1->latest (nano::dev::genesis_key.pub)); auto send = builder - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (previous) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - (node1->online_reps.delta () + 1)) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - (node1->online_reps.delta () + 1)) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) .build_shared (); @@ -532,8 +530,7 @@ TEST (websocket, vote_options_type) ASSERT_TIMELY (5s, ack_ready); // Custom made votes for simplicity - nano::genesis genesis; - auto vote (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, 0, genesis.open)); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, 0, 0, nano::dev::genesis)); nano::websocket::message_builder builder; auto msg (builder.vote_received (vote, nano::vote_code::replay)); node1->websocket_server->broadcast (msg); @@ -563,7 +560,7 @@ TEST (websocket, vote_options_representatives) std::atomic ack_ready{ false }; auto task1 = ([&ack_ready, config, &node1] () { fake_websocket_client client (config.websocket_config.port); - std::string message = boost::str (boost::format (R"json({"action": "subscribe", "topic": "vote", "ack": "true", "options": {"representatives": ["%1%"]}})json") % nano::dev_genesis_key.pub.to_account ()); + std::string message = boost::str (boost::format (R"json({"action": "subscribe", "topic": "vote", "ack": "true", "options": {"representatives": ["%1%"]}})json") % nano::dev::genesis_key.pub.to_account ()); client.send_message (message); client.await_ack (); ack_ready = true; @@ -582,20 +579,20 @@ TEST (websocket, vote_options_representatives) // Quick-confirm a block nano::keypair key; - auto balance = nano::genesis_amount; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + auto balance = nano::dev::constants.genesis_amount; + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto send_amount = node1->online_reps.delta () + 1; auto confirm_block = [&] () { - nano::block_hash previous (node1->latest (nano::dev_genesis_key.pub)); + nano::block_hash previous (node1->latest (nano::dev::genesis_key.pub)); balance -= send_amount; nano::state_block_builder builder; auto send = builder - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (previous) - .representative (nano::dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (balance) .link (key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (previous)) .build_shared (); node1->process_active (send); @@ -724,7 +721,7 @@ TEST (websocket, bootstrap) // Start bootstrap attempt node1->bootstrap_initiator.bootstrap (true, "123abc"); - ASSERT_NE (nullptr, node1->bootstrap_initiator.current_attempt ()); + ASSERT_TIMELY (5s, nullptr == node1->bootstrap_initiator.current_attempt ()); // Wait for the bootstrap notification ASSERT_TIMELY (5s, future.wait_for (0s) == std::future_status::ready); @@ -913,15 +910,14 @@ TEST (websocket, new_unconfirmed_block) nano::state_block_builder builder; // Process a new block - nano::genesis genesis; auto send1 = builder - .account (nano::dev_genesis_key.pub) - .previous (genesis.hash ()) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 1) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (genesis.hash ())) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 1) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build_shared (); ASSERT_EQ (nano::process_result::progress, node1->process_local (send1).code); diff --git a/nano/core_test/work_pool.cpp b/nano/core_test/work_pool.cpp index 6dde98586e..9b4c11c8ca 100644 --- a/nano/core_test/work_pool.cpp +++ b/nano/core_test/work_pool.cpp @@ -16,41 +16,38 @@ TEST (work, one) { - nano::network_constants network_constants; - nano::work_pool pool (std::numeric_limits::max ()); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::change_block block (1, 1, nano::keypair ().prv, 3, 4); block.block_work_set (*pool.generate (block.root ())); - ASSERT_LT (nano::work_threshold_base (block.work_version ()), block.difficulty ()); + ASSERT_LT (nano::dev::network_params.work.threshold_base (block.work_version ()), nano::dev::network_params.work.difficulty (block)); } TEST (work, disabled) { - nano::network_constants network_constants; - nano::work_pool pool (0); + nano::work_pool pool{ nano::dev::network_params.network, 0 }; auto result (pool.generate (nano::block_hash ())); ASSERT_FALSE (result.is_initialized ()); } TEST (work, validate) { - nano::network_constants network_constants; - nano::work_pool pool (std::numeric_limits::max ()); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::send_block send_block (1, 1, 2, nano::keypair ().prv, 4, 6); - ASSERT_LT (send_block.difficulty (), nano::work_threshold_base (send_block.work_version ())); + ASSERT_LT (nano::dev::network_params.work.difficulty (send_block), nano::dev::network_params.work.threshold_base (send_block.work_version ())); send_block.block_work_set (*pool.generate (send_block.root ())); - ASSERT_LT (nano::work_threshold_base (send_block.work_version ()), send_block.difficulty ()); + ASSERT_LT (nano::dev::network_params.work.threshold_base (send_block.work_version ()), nano::dev::network_params.work.difficulty (send_block)); } TEST (work, cancel) { - nano::work_pool pool (std::numeric_limits::max ()); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; auto iterations (0); auto done (false); while (!done) { nano::root key (1); pool.generate ( - nano::work_version::work_1, key, nano::network_constants ().publish_thresholds.base, [&done] (boost::optional work_a) { + nano::work_version::work_1, key, nano::dev::network_params.work.base, [&done] (boost::optional work_a) { done = !work_a; }); pool.cancel (key); @@ -61,20 +58,19 @@ TEST (work, cancel) TEST (work, cancel_many) { - nano::work_pool pool (std::numeric_limits::max ()); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::root key1 (1); nano::root key2 (2); nano::root key3 (1); nano::root key4 (1); nano::root key5 (3); nano::root key6 (1); - nano::network_constants constants; - pool.generate (nano::work_version::work_1, key1, constants.publish_thresholds.base, [] (boost::optional) {}); - pool.generate (nano::work_version::work_1, key2, constants.publish_thresholds.base, [] (boost::optional) {}); - pool.generate (nano::work_version::work_1, key3, constants.publish_thresholds.base, [] (boost::optional) {}); - pool.generate (nano::work_version::work_1, key4, constants.publish_thresholds.base, [] (boost::optional) {}); - pool.generate (nano::work_version::work_1, key5, constants.publish_thresholds.base, [] (boost::optional) {}); - pool.generate (nano::work_version::work_1, key6, constants.publish_thresholds.base, [] (boost::optional) {}); + pool.generate (nano::work_version::work_1, key1, nano::dev::network_params.work.base, [] (boost::optional) {}); + pool.generate (nano::work_version::work_1, key2, nano::dev::network_params.work.base, [] (boost::optional) {}); + pool.generate (nano::work_version::work_1, key3, nano::dev::network_params.work.base, [] (boost::optional) {}); + pool.generate (nano::work_version::work_1, key4, nano::dev::network_params.work.base, [] (boost::optional) {}); + pool.generate (nano::work_version::work_1, key5, nano::dev::network_params.work.base, [] (boost::optional) {}); + pool.generate (nano::work_version::work_1, key6, nano::dev::network_params.work.base, [] (boost::optional) {}); pool.cancel (key1); } @@ -89,13 +85,13 @@ TEST (work, opencl) if (!environment.platforms.empty () && !environment.platforms.begin ()->devices.empty ()) { nano::opencl_config config (0, 0, 16 * 1024); - auto opencl (nano::opencl_work::create (true, config, logger)); + auto opencl (nano::opencl_work::create (true, config, logger, nano::dev::network_params.work)); if (opencl != nullptr) { // 0 threads, should add 1 for managing OpenCL - nano::work_pool pool (0, std::chrono::nanoseconds (0), [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic & ticket_a) { - return opencl->generate_work (version_a, root_a, difficulty_a); - }); + nano::work_pool pool{ nano::dev::network_params.network, 0, std::chrono::nanoseconds (0), [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic & ticket_a) { + return opencl->generate_work (version_a, root_a, difficulty_a); + } }; ASSERT_NE (nullptr, pool.opencl); nano::root root; uint64_t difficulty (0xff00000000000000); @@ -104,7 +100,7 @@ TEST (work, opencl) { nano::random_pool::generate_block (root.bytes.data (), root.bytes.size ()); auto result (*pool.generate (nano::work_version::work_1, root, difficulty)); - ASSERT_GE (nano::work_difficulty (nano::work_version::work_1, root, result), difficulty); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, root, result), difficulty); difficulty += difficulty_add; } } @@ -136,7 +132,7 @@ TEST (work, opencl_config) TEST (work, difficulty) { - nano::work_pool pool (std::numeric_limits::max ()); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::root root (1); uint64_t difficulty1 (0xff00000000000000); uint64_t difficulty2 (0xfff0000000000000); @@ -145,14 +141,14 @@ TEST (work, difficulty) do { auto work1 = *pool.generate (nano::work_version::work_1, root, difficulty1); - result_difficulty1 = nano::work_difficulty (nano::work_version::work_1, root, work1); + result_difficulty1 = nano::dev::network_params.work.difficulty (nano::work_version::work_1, root, work1); } while (result_difficulty1 > difficulty2); ASSERT_GT (result_difficulty1, difficulty1); uint64_t result_difficulty2 (0); do { auto work2 = *pool.generate (nano::work_version::work_1, root, difficulty2); - result_difficulty2 = nano::work_difficulty (nano::work_version::work_1, root, work2); + result_difficulty2 = nano::dev::network_params.work.difficulty (nano::work_version::work_1, root, work2); } while (result_difficulty2 > difficulty3); ASSERT_GT (result_difficulty2, difficulty2); } @@ -160,7 +156,7 @@ TEST (work, difficulty) TEST (work, eco_pow) { auto work_func = [] (std::promise & promise, std::chrono::nanoseconds interval) { - nano::work_pool pool (1, interval); + nano::work_pool pool{ nano::dev::network_params.network, 1, interval }; constexpr auto num_iterations = 5; nano::timer timer; @@ -174,7 +170,7 @@ TEST (work, eco_pow) do { auto work = *pool.generate (nano::work_version::work_1, root, difficulty1); - result_difficulty = nano::work_difficulty (nano::work_version::work_1, root, work); + result_difficulty = nano::dev::network_params.work.difficulty (nano::work_version::work_1, root, work); } while (result_difficulty > difficulty2); ASSERT_GT (result_difficulty, difficulty1); } diff --git a/nano/crypto_lib/random_pool.cpp b/nano/crypto_lib/random_pool.cpp index 4b57d14ff8..398466dc7b 100644 --- a/nano/crypto_lib/random_pool.cpp +++ b/nano/crypto_lib/random_pool.cpp @@ -2,31 +2,26 @@ #include -std::mutex nano::random_pool::mutex; - void nano::random_pool::generate_block (unsigned char * output, size_t size) { auto & pool = get_pool (); - std::lock_guard guard (mutex); pool.GenerateBlock (output, size); } unsigned nano::random_pool::generate_word32 (unsigned min, unsigned max) { auto & pool = get_pool (); - std::lock_guard guard (mutex); return pool.GenerateWord32 (min, max); } unsigned char nano::random_pool::generate_byte () { auto & pool = get_pool (); - std::lock_guard guard (mutex); return pool.GenerateByte (); } CryptoPP::AutoSeededRandomPool & nano::random_pool::get_pool () { - static CryptoPP::AutoSeededRandomPool pool; + static thread_local CryptoPP::AutoSeededRandomPool pool; return pool; } diff --git a/nano/crypto_lib/random_pool.hpp b/nano/crypto_lib/random_pool.hpp index 2afd591fc5..eddfcc0c90 100644 --- a/nano/crypto_lib/random_pool.hpp +++ b/nano/crypto_lib/random_pool.hpp @@ -22,10 +22,9 @@ class random_pool random_pool & operator= (random_pool const &) = delete; private: - static std::mutex mutex; static CryptoPP::AutoSeededRandomPool & get_pool (); template friend void random_pool_shuffle (Iter begin, Iter end); }; -} \ No newline at end of file +} diff --git a/nano/crypto_lib/random_pool_shuffle.hpp b/nano/crypto_lib/random_pool_shuffle.hpp index 0033481041..e718f0473b 100644 --- a/nano/crypto_lib/random_pool_shuffle.hpp +++ b/nano/crypto_lib/random_pool_shuffle.hpp @@ -9,7 +9,6 @@ namespace nano template void random_pool_shuffle (Iter begin, Iter end) { - std::lock_guard guard (random_pool::mutex); random_pool::get_pool ().Shuffle (begin, end); } } diff --git a/nano/crypto_lib/secure_memory.cpp b/nano/crypto_lib/secure_memory.cpp index a0b643b35c..b5f9ae91de 100644 --- a/nano/crypto_lib/secure_memory.cpp +++ b/nano/crypto_lib/secure_memory.cpp @@ -42,7 +42,6 @@ void NOT_OPTIMIZED nano::secure_wipe_memory (void * v, size_t n) #elif defined(HAVE_EXPLICIT_BZERO) explicit_bzero (v, n); #else - static void * (*const volatile memset_sec) (void *, int, size_t) = &memset; - memset_sec (v, 0, n); + memset (v, 0, n); #endif } diff --git a/nano/fuzzer_test/fuzz_bignum.cpp b/nano/fuzzer_test/fuzz_bignum.cpp index 5ead68e282..96ee636a64 100644 --- a/nano/fuzzer_test/fuzz_bignum.cpp +++ b/nano/fuzzer_test/fuzz_bignum.cpp @@ -1,7 +1,7 @@ #include /** Fuzz decimal, hex and account parsing */ -void fuzz_bignum_parsers (const uint8_t * Data, size_t Size) +void fuzz_bignum_parsers (uint8_t const * Data, size_t Size) { try { @@ -29,7 +29,7 @@ void fuzz_bignum_parsers (const uint8_t * Data, size_t Size) } /** Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput (const uint8_t * Data, size_t Size) +extern "C" int LLVMFuzzerTestOneInput (uint8_t const * Data, size_t Size) { fuzz_bignum_parsers (Data, Size); return 0; diff --git a/nano/fuzzer_test/fuzz_buffer.cpp b/nano/fuzzer_test/fuzz_buffer.cpp index be4d41b466..161ccdcfc4 100644 --- a/nano/fuzzer_test/fuzz_buffer.cpp +++ b/nano/fuzzer_test/fuzz_buffer.cpp @@ -56,7 +56,7 @@ class fuzz_visitor : public nano::message_visitor } /** Fuzz live message parsing. This covers parsing and block/vote uniquing. */ -void fuzz_message_parser (const uint8_t * Data, size_t Size) +void fuzz_message_parser (uint8_t const * Data, size_t Size) { static bool initialized = false; if (!initialized) @@ -73,7 +73,7 @@ void fuzz_message_parser (const uint8_t * Data, size_t Size) } /** Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput (const uint8_t * Data, size_t Size) +extern "C" int LLVMFuzzerTestOneInput (uint8_t const * Data, size_t Size) { fuzz_message_parser (Data, Size); return 0; diff --git a/nano/fuzzer_test/fuzz_endpoint_parsing.cpp b/nano/fuzzer_test/fuzz_endpoint_parsing.cpp index 0308787d1f..b132a9321e 100644 --- a/nano/fuzzer_test/fuzz_endpoint_parsing.cpp +++ b/nano/fuzzer_test/fuzz_endpoint_parsing.cpp @@ -1,7 +1,7 @@ #include /** Fuzz endpoint parsing */ -void fuzz_endpoint_parsing (const uint8_t * Data, size_t Size) +void fuzz_endpoint_parsing (uint8_t const * Data, size_t Size) { auto data (std::string (reinterpret_cast (const_cast (Data)), Size)); nano::endpoint endpoint; @@ -11,7 +11,7 @@ void fuzz_endpoint_parsing (const uint8_t * Data, size_t Size) } /** Fuzzer entry point */ -extern "C" int LLVMFuzzerTestOneInput (const uint8_t * Data, size_t Size) +extern "C" int LLVMFuzzerTestOneInput (uint8_t const * Data, size_t Size) { fuzz_endpoint_parsing (Data, Size); return 0; diff --git a/nano/ipc_flatbuffers_lib/CMakeLists.txt b/nano/ipc_flatbuffers_lib/CMakeLists.txt index d7e1d9ad4c..1cf92097d6 100644 --- a/nano/ipc_flatbuffers_lib/CMakeLists.txt +++ b/nano/ipc_flatbuffers_lib/CMakeLists.txt @@ -48,6 +48,12 @@ foreach(file ${files}) message( "Generating flatbuffers code for: ${flatbuffers_filename} into ${CMAKE_CURRENT_SOURCE_DIR}/generated/flatbuffers" ) + + configure_file( + ${file} + ${PROJECT_BINARY_DIR}/${CMAKE_BUILD_TYPE}/api/flatbuffers/${flatbuffers_filename}.fbs + COPYONLY) + add_custom_command( OUTPUT ${CMAKE_CURRENT_SOURCE_DIR}/generated/flatbuffers/${flatbuffers_filename}_generated.h diff --git a/nano/lib/CMakeLists.txt b/nano/lib/CMakeLists.txt index 3a99d8f25d..59fb80faf6 100644 --- a/nano/lib/CMakeLists.txt +++ b/nano/lib/CMakeLists.txt @@ -30,6 +30,8 @@ add_library( config.hpp config.cpp configbase.hpp + convert.cpp + convert.hpp diagnosticsconfig.hpp diagnosticsconfig.cpp epoch.hpp @@ -71,6 +73,8 @@ add_library( threading.cpp timer.hpp timer.cpp + tlsconfig.hpp + tlsconfig.cpp tomlconfig.hpp tomlconfig.cpp utility.hpp diff --git a/nano/lib/asio.cpp b/nano/lib/asio.cpp index 6d0a5b7fed..b73e1b8630 100644 --- a/nano/lib/asio.cpp +++ b/nano/lib/asio.cpp @@ -1,6 +1,6 @@ #include -nano::shared_const_buffer::shared_const_buffer (const std::vector & data) : +nano::shared_const_buffer::shared_const_buffer (std::vector const & data) : m_data (std::make_shared> (data)), m_buffer (boost::asio::buffer (*m_data)) { @@ -29,17 +29,17 @@ nano::shared_const_buffer::shared_const_buffer (std::shared_ptr const & data); explicit shared_const_buffer (uint8_t data); @@ -16,10 +16,10 @@ class shared_const_buffer explicit shared_const_buffer (std::vector && data); explicit shared_const_buffer (std::shared_ptr> const & data); - const boost::asio::const_buffer * begin () const; - const boost::asio::const_buffer * end () const; + boost::asio::const_buffer const * begin () const; + boost::asio::const_buffer const * end () const; - size_t size () const; + std::size_t size () const; private: std::shared_ptr> m_data; diff --git a/nano/lib/blocks.cpp b/nano/lib/blocks.cpp index 4515b78d07..224e07c7d0 100644 --- a/nano/lib/blocks.cpp +++ b/nano/lib/blocks.cpp @@ -1,8 +1,10 @@ #include #include +#include #include #include #include +#include #include @@ -83,11 +85,6 @@ nano::work_version nano::block::work_version () const return nano::work_version::work_1; } -uint64_t nano::block::difficulty () const -{ - return nano::work_difficulty (this->work_version (), this->root (), this->block_work ()); -} - nano::block_hash nano::block::generate_hash () const { nano::block_hash result; @@ -156,8 +153,8 @@ bool nano::block::has_sideband () const nano::account const & nano::block::representative () const { - static nano::account rep{ 0 }; - return rep; + static nano::account representative{}; + return representative; } nano::block_hash const & nano::block::source () const @@ -168,7 +165,7 @@ nano::block_hash const & nano::block::source () const nano::account const & nano::block::destination () const { - static nano::account destination{ 0 }; + static nano::account destination{}; return destination; } @@ -180,7 +177,7 @@ nano::link const & nano::block::link () const nano::account const & nano::block::account () const { - static nano::account account{ 0 }; + static nano::account account{}; return account; } @@ -321,6 +318,7 @@ void nano::send_block::serialize_json (boost::property_tree::ptree & tree) const std::string balance; hashables.balance.encode_hex (balance); tree.put ("balance", balance); + tree.put ("balance_decimal", convert_raw_to_dec (hashables.balance.to_string_dec ())); std::string signature_l; signature.encode_hex (signature_l); tree.put ("work", nano::to_string_hex (work)); @@ -368,6 +366,8 @@ nano::send_block::send_block (nano::block_hash const & previous_a, nano::account signature (nano::sign_message (prv_a, pub_a, hash ())), work (work_a) { + debug_assert (destination_a != nullptr); + debug_assert (pub_a != nullptr); } nano::send_block::send_block (bool & error_a, nano::stream & stream_a) : @@ -529,13 +529,18 @@ nano::open_block::open_block (nano::block_hash const & source_a, nano::account c signature (nano::sign_message (prv_a, pub_a, hash ())), work (work_a) { - debug_assert (!representative_a.is_zero ()); + debug_assert (representative_a != nullptr); + debug_assert (account_a != nullptr); + debug_assert (pub_a != nullptr); } nano::open_block::open_block (nano::block_hash const & source_a, nano::account const & representative_a, nano::account const & account_a, std::nullptr_t) : hashables (source_a, representative_a, account_a), work (0) { + debug_assert (representative_a != nullptr); + debug_assert (account_a != nullptr); + signature.clear (); } @@ -792,6 +797,8 @@ nano::change_block::change_block (nano::block_hash const & previous_a, nano::acc signature (nano::sign_message (prv_a, pub_a, hash ())), work (work_a) { + debug_assert (representative_a != nullptr); + debug_assert (pub_a != nullptr); } nano::change_block::change_block (bool & error_a, nano::stream & stream_a) : @@ -1065,6 +1072,10 @@ nano::state_block::state_block (nano::account const & account_a, nano::block_has signature (nano::sign_message (prv_a, pub_a, hash ())), work (work_a) { + debug_assert (account_a != nullptr); + debug_assert (representative_a != nullptr); + debug_assert (link_a.as_account () != nullptr); + debug_assert (pub_a != nullptr); } nano::state_block::state_block (bool & error_a, nano::stream & stream_a) : @@ -1188,6 +1199,7 @@ void nano::state_block::serialize_json (boost::property_tree::ptree & tree) cons tree.put ("previous", hashables.previous.to_string ()); tree.put ("representative", representative ().to_account ()); tree.put ("balance", hashables.balance.to_string_dec ()); + tree.put ("balance_decimal", convert_raw_to_dec (hashables.balance.to_string_dec ())); tree.put ("link", hashables.link.to_string ()); tree.put ("link_as_account", hashables.link.to_account ()); std::string signature_l; @@ -1510,6 +1522,7 @@ nano::receive_block::receive_block (nano::block_hash const & previous_a, nano::b signature (nano::sign_message (prv_a, pub_a, hash ())), work (work_a) { + debug_assert (pub_a != nullptr); } nano::receive_block::receive_block (bool & error_a, nano::stream & stream_a) : diff --git a/nano/lib/blocks.hpp b/nano/lib/blocks.hpp index 29011bacaf..3d5796276d 100644 --- a/nano/lib/blocks.hpp +++ b/nano/lib/blocks.hpp @@ -64,7 +64,7 @@ class block_sideband final bool deserialize (nano::stream &, nano::block_type); static size_t size (nano::block_type); nano::block_hash successor{ 0 }; - nano::account account{ 0 }; + nano::account account{}; nano::amount balance{ 0 }; uint64_t height{ 0 }; uint64_t timestamp{ 0 }; @@ -113,7 +113,6 @@ class block virtual bool valid_predecessor (nano::block const &) const = 0; static size_t size (nano::block_type); virtual nano::work_version work_version () const; - uint64_t difficulty () const; // If there are any changes to the hashables, call this to update the cached hash void refresh (); @@ -140,7 +139,7 @@ class send_hashables nano::block_hash previous; nano::account destination; nano::amount balance; - static size_t constexpr size = sizeof (previous) + sizeof (destination) + sizeof (balance); + static std::size_t constexpr size = sizeof (previous) + sizeof (destination) + sizeof (balance); }; class send_block : public nano::block { @@ -174,7 +173,7 @@ class send_block : public nano::block send_hashables hashables; nano::signature signature; uint64_t work; - static size_t constexpr size = nano::send_hashables::size + sizeof (signature) + sizeof (work); + static std::size_t constexpr size = nano::send_hashables::size + sizeof (signature) + sizeof (work); }; class receive_hashables { @@ -186,7 +185,7 @@ class receive_hashables void hash (blake2b_state &) const; nano::block_hash previous; nano::block_hash source; - static size_t constexpr size = sizeof (previous) + sizeof (source); + static std::size_t constexpr size = sizeof (previous) + sizeof (source); }; class receive_block : public nano::block { @@ -219,7 +218,7 @@ class receive_block : public nano::block receive_hashables hashables; nano::signature signature; uint64_t work; - static size_t constexpr size = nano::receive_hashables::size + sizeof (signature) + sizeof (work); + static std::size_t constexpr size = nano::receive_hashables::size + sizeof (signature) + sizeof (work); }; class open_hashables { @@ -232,7 +231,7 @@ class open_hashables nano::block_hash source; nano::account representative; nano::account account; - static size_t constexpr size = sizeof (source) + sizeof (representative) + sizeof (account); + static std::size_t constexpr size = sizeof (source) + sizeof (representative) + sizeof (account); }; class open_block : public nano::block { @@ -268,7 +267,7 @@ class open_block : public nano::block nano::open_hashables hashables; nano::signature signature; uint64_t work; - static size_t constexpr size = nano::open_hashables::size + sizeof (signature) + sizeof (work); + static std::size_t constexpr size = nano::open_hashables::size + sizeof (signature) + sizeof (work); }; class change_hashables { @@ -280,7 +279,7 @@ class change_hashables void hash (blake2b_state &) const; nano::block_hash previous; nano::account representative; - static size_t constexpr size = sizeof (previous) + sizeof (representative); + static std::size_t constexpr size = sizeof (previous) + sizeof (representative); }; class change_block : public nano::block { @@ -313,7 +312,7 @@ class change_block : public nano::block nano::change_hashables hashables; nano::signature signature; uint64_t work; - static size_t constexpr size = nano::change_hashables::size + sizeof (signature) + sizeof (work); + static std::size_t constexpr size = nano::change_hashables::size + sizeof (signature) + sizeof (work); }; class state_hashables { @@ -338,7 +337,7 @@ class state_hashables // Link field contains source block_hash if receiving, destination account if sending nano::link link; // Serialized size - static size_t constexpr size = sizeof (account) + sizeof (previous) + sizeof (representative) + sizeof (balance) + sizeof (link); + static std::size_t constexpr size = sizeof (account) + sizeof (previous) + sizeof (representative) + sizeof (balance) + sizeof (link); }; class state_block : public nano::block { @@ -374,7 +373,7 @@ class state_block : public nano::block nano::state_hashables hashables; nano::signature signature; uint64_t work; - static size_t constexpr size = nano::state_hashables::size + sizeof (signature) + sizeof (work); + static std::size_t constexpr size = nano::state_hashables::size + sizeof (signature) + sizeof (work); }; class block_visitor { @@ -402,7 +401,7 @@ class mutable_block_visitor class block_uniquer { public: - using value_type = std::pair>; + using value_type = std::pair>; std::shared_ptr unique (std::shared_ptr const &); size_t size (); diff --git a/nano/lib/config.cpp b/nano/lib/config.cpp index d24b7b3bee..2fda279bbd 100644 --- a/nano/lib/config.cpp +++ b/nano/lib/config.cpp @@ -1,3 +1,4 @@ +#include #include #include @@ -24,33 +25,192 @@ struct HexTo }; } // namespace -namespace nano -{ -work_thresholds const network_constants::publish_full ( +nano::work_thresholds const nano::work_thresholds::publish_full ( 0xfffffe0000000000, 0xfffffff000000000, // 32x higher than originally 0x0000000000000000 // remove receive work requirements ); -work_thresholds const network_constants::publish_beta ( +nano::work_thresholds const nano::work_thresholds::publish_beta ( 0xfffff00000000000, // 64x lower than publish_full.epoch_1 0xfffff00000000000, // same as epoch_1 0xffffe00000000000 // 2x lower than epoch_1 ); -work_thresholds const network_constants::publish_dev ( +nano::work_thresholds const nano::work_thresholds::publish_dev ( 0xfe00000000000000, // Very low for tests 0xffc0000000000000, // 8x higher than epoch_1 0xf000000000000000 // 8x lower than epoch_1 ); -work_thresholds const network_constants::publish_test ( //defaults to live network levels -get_env_threshold_or_default ("NANO_TEST_EPOCH_1", 0xfffffe0000000000), +nano::work_thresholds const nano::work_thresholds::publish_test ( //defaults to live network levels +get_env_threshold_or_default ("NANO_TEST_EPOCH_1", 0xffffffc000000000), get_env_threshold_or_default ("NANO_TEST_EPOCH_2", 0xfffffff800000000), // 8x higher than epoch_1 get_env_threshold_or_default ("NANO_TEST_EPOCH_2_RECV", 0xfffffe0000000000) // 8x lower than epoch_1 ); -const char * network_constants::active_network_err_msg = "Invalid network. Valid values are live, test, beta and dev."; +uint64_t nano::work_thresholds::threshold_entry (nano::work_version const version_a, nano::block_type const type_a) const +{ + uint64_t result{ std::numeric_limits::max () }; + if (type_a == nano::block_type::state) + { + switch (version_a) + { + case nano::work_version::work_1: + result = entry; + break; + default: + debug_assert (false && "Invalid version specified to work_threshold_entry"); + } + } + else + { + result = epoch_1; + } + return result; +} + +#ifndef NANO_FUZZER_TEST +uint64_t nano::work_thresholds::value (nano::root const & root_a, uint64_t work_a) const +{ + uint64_t result; + blake2b_state hash; + blake2b_init (&hash, sizeof (result)); + blake2b_update (&hash, reinterpret_cast (&work_a), sizeof (work_a)); + blake2b_update (&hash, root_a.bytes.data (), root_a.bytes.size ()); + blake2b_final (&hash, reinterpret_cast (&result), sizeof (result)); + return result; +} +#else +uint64_t nano::work_thresholds::value (nano::root const & root_a, uint64_t work_a) const +{ + return base + 1; +} +#endif + +uint64_t nano::work_thresholds::threshold (nano::block_details const & details_a) const +{ + static_assert (nano::epoch::max == nano::epoch::epoch_2, "work_v1::threshold is ill-defined"); + + uint64_t result{ std::numeric_limits::max () }; + switch (details_a.epoch) + { + case nano::epoch::epoch_2: + result = (details_a.is_receive || details_a.is_epoch) ? epoch_2_receive : epoch_2; + break; + case nano::epoch::epoch_1: + case nano::epoch::epoch_0: + result = epoch_1; + break; + default: + debug_assert (false && "Invalid epoch specified to work_v1 ledger work_threshold"); + } + return result; +} + +uint64_t nano::work_thresholds::threshold (nano::work_version const version_a, nano::block_details const details_a) const +{ + uint64_t result{ std::numeric_limits::max () }; + switch (version_a) + { + case nano::work_version::work_1: + result = threshold (details_a); + break; + default: + debug_assert (false && "Invalid version specified to ledger work_threshold"); + } + return result; +} + +double nano::work_thresholds::normalized_multiplier (double const multiplier_a, uint64_t const threshold_a) const +{ + debug_assert (multiplier_a >= 1); + auto multiplier (multiplier_a); + /* Normalization rules + ratio = multiplier of max work threshold (send epoch 2) from given threshold + i.e. max = 0xfe00000000000000, given = 0xf000000000000000, ratio = 8.0 + normalized = (multiplier + (ratio - 1)) / ratio; + Epoch 1 + multiplier | normalized + 1.0 | 1.0 + 9.0 | 2.0 + 25.0 | 4.0 + Epoch 2 (receive / epoch subtypes) + multiplier | normalized + 1.0 | 1.0 + 65.0 | 2.0 + 241.0 | 4.0 + */ + if (threshold_a == epoch_1 || threshold_a == epoch_2_receive) + { + auto ratio (nano::difficulty::to_multiplier (epoch_2, threshold_a)); + debug_assert (ratio >= 1); + multiplier = (multiplier + (ratio - 1.0)) / ratio; + debug_assert (multiplier >= 1); + } + return multiplier; +} + +double nano::work_thresholds::denormalized_multiplier (double const multiplier_a, uint64_t const threshold_a) const +{ + debug_assert (multiplier_a >= 1); + auto multiplier (multiplier_a); + if (threshold_a == epoch_1 || threshold_a == epoch_2_receive) + { + auto ratio (nano::difficulty::to_multiplier (epoch_2, threshold_a)); + debug_assert (ratio >= 1); + multiplier = multiplier * ratio + 1.0 - ratio; + debug_assert (multiplier >= 1); + } + return multiplier; +} + +uint64_t nano::work_thresholds::threshold_base (nano::work_version const version_a) const +{ + uint64_t result{ std::numeric_limits::max () }; + switch (version_a) + { + case nano::work_version::work_1: + result = base; + break; + default: + debug_assert (false && "Invalid version specified to work_threshold_base"); + } + return result; +} + +uint64_t nano::work_thresholds::difficulty (nano::work_version const version_a, nano::root const & root_a, uint64_t const work_a) const +{ + uint64_t result{ 0 }; + switch (version_a) + { + case nano::work_version::work_1: + result = value (root_a, work_a); + break; + default: + debug_assert (false && "Invalid version specified to work_difficulty"); + } + return result; +} + +uint64_t nano::work_thresholds::difficulty (nano::block const & block_a) const +{ + return difficulty (block_a.work_version (), block_a.root (), block_a.block_work ()); +} + +bool nano::work_thresholds::validate_entry (nano::work_version const version_a, nano::root const & root_a, uint64_t const work_a) const +{ + return difficulty (version_a, root_a, work_a) < threshold_entry (version_a, nano::block_type::state); +} + +bool nano::work_thresholds::validate_entry (nano::block const & block_a) const +{ + return difficulty (block_a) < threshold_entry (block_a.work_version (), block_a.type ()); +} + +namespace nano +{ +char const * network_constants::active_network_err_msg = "Invalid network. Valid values are live, test, beta and dev."; uint8_t get_major_node_version () { @@ -112,7 +272,7 @@ std::array test_magic_number () void force_nano_dev_network () { - nano::network_constants::set_active_network (nano::nano_networks::nano_dev_network); + nano::network_constants::set_active_network (nano::networks::nano_dev_network); } bool running_within_valgrind () @@ -144,8 +304,14 @@ std::string get_qtwallet_toml_config_path (boost::filesystem::path const & data_ { return (data_path / "config-qtwallet.toml").string (); } + std::string get_access_toml_config_path (boost::filesystem::path const & data_path) { return (data_path / "config-access.toml").string (); } + +std::string get_tls_toml_config_path (boost::filesystem::path const & data_path) +{ + return (data_path / "config-tls.toml").string (); +} } // namespace nano diff --git a/nano/lib/config.hpp b/nano/lib/config.hpp index 001d0663e5..c261dedf89 100644 --- a/nano/lib/config.hpp +++ b/nano/lib/config.hpp @@ -5,6 +5,7 @@ #include #include +#include #include namespace boost @@ -21,26 +22,26 @@ namespace filesystem /** * Returns build version information */ -const char * const NANO_VERSION_STRING = xstr (TAG_VERSION_STRING); -const char * const NANO_MAJOR_VERSION_STRING = xstr (MAJOR_VERSION_STRING); -const char * const NANO_MINOR_VERSION_STRING = xstr (MINOR_VERSION_STRING); -const char * const NANO_PATCH_VERSION_STRING = xstr (PATCH_VERSION_STRING); -const char * const NANO_PRE_RELEASE_VERSION_STRING = xstr (PRE_RELEASE_VERSION_STRING); +char const * const NANO_VERSION_STRING = xstr (TAG_VERSION_STRING); +char const * const NANO_MAJOR_VERSION_STRING = xstr (MAJOR_VERSION_STRING); +char const * const NANO_MINOR_VERSION_STRING = xstr (MINOR_VERSION_STRING); +char const * const NANO_PATCH_VERSION_STRING = xstr (PATCH_VERSION_STRING); +char const * const NANO_PRE_RELEASE_VERSION_STRING = xstr (PRE_RELEASE_VERSION_STRING); -const char * const BUILD_INFO = xstr (GIT_COMMIT_HASH BOOST_COMPILER) " \"BOOST " xstr (BOOST_VERSION) "\" BUILT " xstr (__DATE__); +char const * const BUILD_INFO = xstr (GIT_COMMIT_HASH BOOST_COMPILER) " \"BOOST " xstr (BOOST_VERSION) "\" BUILT " xstr (__DATE__); /** Is TSAN/ASAN dev build */ #if defined(__has_feature) #if __has_feature(thread_sanitizer) || __has_feature(address_sanitizer) -const bool is_sanitizer_build = true; +bool const is_sanitizer_build = true; #else -const bool is_sanitizer_build = false; +bool const is_sanitizer_build = false; #endif // GCC builds #elif defined(__SANITIZE_THREAD__) || defined(__SANITIZE_ADDRESS__) const bool is_sanitizer_build = true; #else -const bool is_sanitizer_build = false; +bool const is_sanitizer_build = false; #endif namespace nano @@ -61,26 +62,33 @@ std::array test_magic_number (); /** * Network variants with different genesis blocks and network parameters - * @warning Enum values are used in integral comparisons; do not change. */ -enum class nano_networks +enum class networks : uint16_t { + invalid = 0x0, // Low work parameters, publicly known genesis key, dev IP ports - nano_dev_network = 0, - banano_dev_network = 0, + nano_dev_network = 0x4241, // 'B', 'A' // Normal work parameters, secret beta genesis key, beta IP ports - nano_beta_network = 1, - banano_beta_network = 1, + nano_beta_network = 0x4242, // 'B', 'B' // Normal work parameters, secret live key, live IP ports - nano_live_network = 2, - banano_live_network = 2, + nano_live_network = 0x4258, // 'B', 'X' // Normal work parameters, secret test genesis key, test IP ports - nano_test_network = 3, - banano_test_network = 3, + nano_test_network = 0x4243, // 'B', 'C' }; -struct work_thresholds +enum class work_version { + unspecified, + work_1 +}; +enum class block_type : uint8_t; +class root; +class block; +class block_details; + +class work_thresholds +{ +public: uint64_t const epoch_1; uint64_t const epoch_2; uint64_t const epoch_2_receive; @@ -102,42 +110,68 @@ struct work_thresholds { return other_a; } + + uint64_t threshold_entry (nano::work_version const, nano::block_type const) const; + uint64_t threshold (nano::block_details const &) const; + // Ledger threshold + uint64_t threshold (nano::work_version const, nano::block_details const) const; + uint64_t threshold_base (nano::work_version const) const; + uint64_t value (nano::root const & root_a, uint64_t work_a) const; + double normalized_multiplier (double const, uint64_t const) const; + double denormalized_multiplier (double const, uint64_t const) const; + uint64_t difficulty (nano::work_version const, nano::root const &, uint64_t const) const; + uint64_t difficulty (nano::block const & block_a) const; + bool validate_entry (nano::work_version const, nano::root const &, uint64_t const) const; + bool validate_entry (nano::block const &) const; + + /** Network work thresholds. Define these inline as constexpr when moving to cpp17. */ + static nano::work_thresholds const publish_full; + static nano::work_thresholds const publish_beta; + static nano::work_thresholds const publish_dev; + static nano::work_thresholds const publish_test; }; class network_constants { public: - network_constants () : - network_constants (network_constants::active_network) - { - } - - network_constants (nano_networks network_a) : + network_constants (nano::work_thresholds & work, nano::networks network_a) : current_network (network_a), - publish_thresholds (is_live_network () ? publish_full : is_beta_network () ? publish_beta : is_test_network () ? publish_test : publish_dev) + work{ work } { // A representative is classified as principal based on its weight and this factor principal_weight_factor = 2000; // 0.2% - default_node_port = is_live_network () ? 7071 : is_beta_network () ? 54000 : is_test_network () ? test_node_port () : 44000; - default_rpc_port = is_live_network () ? 7072 : is_beta_network () ? 55000 : is_test_network () ? test_rpc_port () : 45000; - default_ipc_port = is_live_network () ? 7073 : is_beta_network () ? 56000 : is_test_network () ? test_ipc_port () : 46000; - default_websocket_port = is_live_network () ? 7074 : is_beta_network () ? 57000 : is_test_network () ? test_websocket_port () : 47000; + default_node_port = is_live_network () ? 7071 : is_beta_network () ? 54000 + : is_test_network () ? test_node_port () + : 44000; + default_rpc_port = is_live_network () ? 7072 : is_beta_network () ? 55000 + : is_test_network () ? test_rpc_port () + : 45000; + default_ipc_port = is_live_network () ? 7073 : is_beta_network () ? 56000 + : is_test_network () ? test_ipc_port () + : 46000; + default_websocket_port = is_live_network () ? 7074 : is_beta_network () ? 57000 + : is_test_network () ? test_websocket_port () + : 47000; request_interval_ms = is_dev_network () ? 20 : 500; + cleanup_period = is_dev_network () ? std::chrono::seconds (1) : std::chrono::seconds (60); + socket_dev_idle_timeout = std::chrono::seconds (2); + idle_timeout = is_dev_network () ? cleanup_period * 15 : cleanup_period * 2; + silent_connection_tolerance_time = std::chrono::seconds (120); + syn_cookie_cutoff = std::chrono::seconds (5); + bootstrap_interval = std::chrono::seconds (15 * 60); + max_peers_per_ip = is_dev_network () ? 20 : 10; + max_peers_per_subnetwork = max_peers_per_ip * 4; + ipv6_subnetwork_prefix_for_limiting = 64; // Equivalent to network prefix /64. + peer_dump_interval = is_dev_network () ? std::chrono::seconds (1) : std::chrono::seconds (5 * 60); } - /** Network work thresholds. Define these inline as constexpr when moving to cpp17. */ - static const nano::work_thresholds publish_full; - static const nano::work_thresholds publish_beta; - static const nano::work_thresholds publish_dev; - static const nano::work_thresholds publish_test; - /** Error message when an invalid network is specified */ - static const char * active_network_err_msg; + static char const * active_network_err_msg; /** The network this param object represents. This may differ from the global active network; this is needed for certain --debug... commands */ - nano_networks current_network{ nano::network_constants::active_network }; - nano::work_thresholds publish_thresholds; + nano::networks current_network{ nano::network_constants::active_network }; + nano::work_thresholds & work; unsigned principal_weight_factor; uint16_t default_node_port; @@ -146,8 +180,30 @@ class network_constants uint16_t default_websocket_port; unsigned request_interval_ms; + std::chrono::seconds cleanup_period; + std::chrono::milliseconds cleanup_period_half () const + { + return std::chrono::duration_cast (cleanup_period) / 2; + } + std::chrono::seconds cleanup_cutoff () const + { + return cleanup_period * 5; + } + /** Default maximum idle time for a socket before it's automatically closed */ + std::chrono::seconds socket_dev_idle_timeout; + std::chrono::seconds idle_timeout; + std::chrono::seconds silent_connection_tolerance_time; + std::chrono::seconds syn_cookie_cutoff; + std::chrono::seconds bootstrap_interval; + /** Maximum number of peers per IP. It is also the max number of connections per IP */ + size_t max_peers_per_ip; + /** Maximum number of peers per subnetwork */ + size_t max_peers_per_subnetwork; + size_t ipv6_subnetwork_prefix_for_limiting; + std::chrono::seconds peer_dump_interval; + /** Returns the network this object contains values for */ - nano_networks network () const + nano::networks network () const { return current_network; } @@ -157,7 +213,7 @@ class network_constants * If not called, the compile-time option will be used. * @param network_a The new active network */ - static void set_active_network (nano_networks network_a) + static void set_active_network (nano::networks network_a) { active_network = network_a; } @@ -172,19 +228,19 @@ class network_constants auto error{ false }; if (network_a == "live") { - active_network = nano::nano_networks::nano_live_network; + active_network = nano::networks::nano_live_network; } else if (network_a == "beta") { - active_network = nano::nano_networks::nano_beta_network; + active_network = nano::networks::nano_beta_network; } else if (network_a == "dev") { - active_network = nano::nano_networks::nano_dev_network; + active_network = nano::networks::nano_dev_network; } else if (network_a == "test") { - active_network = nano::nano_networks::nano_test_network; + active_network = nano::networks::nano_test_network; } else { @@ -193,30 +249,36 @@ class network_constants return error; } - const char * get_current_network_as_string () const + char const * get_current_network_as_string () { - return is_live_network () ? "live" : is_beta_network () ? "beta" : is_test_network () ? "test" : "dev"; + return is_live_network () ? "live" : is_beta_network () ? "beta" + : is_test_network () ? "test" + : "dev"; } bool is_live_network () const { - return current_network == nano_networks::nano_live_network; + return current_network == nano::networks::nano_live_network; } bool is_beta_network () const { - return current_network == nano_networks::nano_beta_network; + return current_network == nano::networks::nano_beta_network; } bool is_dev_network () const { - return current_network == nano_networks::nano_dev_network; + return current_network == nano::networks::nano_dev_network; } bool is_test_network () const { - return current_network == nano_networks::nano_test_network; + return current_network == nano::networks::nano_test_network; } /** Initial value is ACTIVE_NETWORK compile flag, but can be overridden by a CLI flag */ - static nano::nano_networks active_network; + static nano::networks active_network; + /** Current protocol version */ + uint8_t const protocol_version = 0x12; + /** Minimum accepted protocol version */ + uint8_t const protocol_version_min = 0x12; }; std::string get_config_path (boost::filesystem::path const & data_path); @@ -225,6 +287,7 @@ std::string get_node_toml_config_path (boost::filesystem::path const & data_path std::string get_rpc_toml_config_path (boost::filesystem::path const & data_path); std::string get_access_toml_config_path (boost::filesystem::path const & data_path); std::string get_qtwallet_toml_config_path (boost::filesystem::path const & data_path); +std::string get_tls_toml_config_path (boost::filesystem::path const & data_path); /** Checks if we are running inside a valgrind instance */ bool running_within_valgrind (); diff --git a/nano/lib/convert.cpp b/nano/lib/convert.cpp new file mode 100644 index 0000000000..ca6030fca3 --- /dev/null +++ b/nano/lib/convert.cpp @@ -0,0 +1,36 @@ +#include + +std::string convert_raw_to_dec (std::string amount_raw, nano::uint128_t ratio) +{ + std::string amount_in_dec = amount_raw; //initialize variable + int amount_length = amount_raw.length (); //count digits of input + int divider_length = ratio.convert_to ().length (); //count digits of ratio divider + + if (divider_length > amount_length) // if amount is less than 1 whole unit of the desired output + { + int rest = divider_length - amount_length; // calculate the number of zeros we need after the decimal separator + for (int i = 1; i < rest; i++) + { + amount_in_dec = "0" + amount_in_dec; // add another trailing zero after decimal separator + } + amount_in_dec = "0." + amount_in_dec; // add the leading zero + } + else // if amount is at least one whole unit of the desired output + { + amount_in_dec.insert (amount_in_dec.end () - (divider_length - 1), '.'); // add a dot according to the desired divider + } + + int unnecessarytrailingzeroscounter = 0; + while (amount_in_dec[amount_in_dec.length () - 1 - unnecessarytrailingzeroscounter] == '0') + { + unnecessarytrailingzeroscounter++; // count trailing zeros + } + // if there's no trailing decimals at all because we solely have a whole unit, then lower the counter to keep one 0 after the dot + if (unnecessarytrailingzeroscounter == (divider_length - 1)) + { + unnecessarytrailingzeroscounter--; + } + + amount_in_dec.erase (amount_in_dec.length () - unnecessarytrailingzeroscounter, amount_in_dec.length ()); // remove unnecessary trailing zeros. first parameter is the pos after which the cutoff begins, second parameter is supposed to be the number of characters to be truncated but if it's chosen too high it will just stop at the end + return amount_in_dec; +} \ No newline at end of file diff --git a/nano/lib/convert.hpp b/nano/lib/convert.hpp new file mode 100644 index 0000000000..a6eb76ac65 --- /dev/null +++ b/nano/lib/convert.hpp @@ -0,0 +1,3 @@ +#include + +std::string convert_raw_to_dec (std::string amount_raw, nano::uint128_t ratio = nano::BAN_ratio); // using 10^29 by default if not specifically set to other ratio \ No newline at end of file diff --git a/nano/lib/errors.cpp b/nano/lib/errors.cpp index 41e2b2003a..742a7d2ae0 100644 --- a/nano/lib/errors.cpp +++ b/nano/lib/errors.cpp @@ -280,30 +280,31 @@ std::string nano::error_config_messages::message (int ev) const return "Invalid error code"; } -const char * nano::error_conversion::detail::generic_category::name () const noexcept +char const * nano::error_conversion::detail::generic_category::name () const noexcept { return boost::system::generic_category ().name (); } + std::string nano::error_conversion::detail::generic_category::message (int value) const { return boost::system::generic_category ().message (value); } -const std::error_category & nano::error_conversion::generic_category () +std::error_category const & nano::error_conversion::generic_category () { static detail::generic_category instance; return instance; } -std::error_code nano::error_conversion::convert (const boost::system::error_code & error) +std::error_code nano::error_conversion::convert (boost::system::error_code const & error) { if (error.category () == boost::system::generic_category ()) { return std::error_code (error.value (), nano::error_conversion::generic_category ()); } - debug_assert (false); + debug_assert (false); return nano::error_common::invalid_type_conversion; } @@ -344,7 +345,7 @@ nano::error & nano::error::operator= (nano::error && err_a) } /** Assign error code */ -nano::error & nano::error::operator= (const std::error_code code_a) +nano::error & nano::error::operator= (std::error_code const code_a) { code = code_a; message.clear (); @@ -352,7 +353,7 @@ nano::error & nano::error::operator= (const std::error_code code_a) } /** Assign boost error code (as converted to std::error_code) */ -nano::error & nano::error::operator= (const boost::system::error_code & code_a) +nano::error & nano::error::operator= (boost::system::error_code const & code_a) { code = nano::error_conversion::convert (code_a); message.clear (); @@ -360,7 +361,7 @@ nano::error & nano::error::operator= (const boost::system::error_code & code_a) } /** Assign boost error code (as converted to std::error_code) */ -nano::error & nano::error::operator= (const boost::system::errc::errc_t & code_a) +nano::error & nano::error::operator= (boost::system::errc::errc_t const & code_a) { code = nano::error_conversion::convert (boost::system::errc::make_error_code (code_a)); message.clear (); @@ -368,7 +369,7 @@ nano::error & nano::error::operator= (const boost::system::errc::errc_t & code_a } /** Set the error to nano::error_common::generic and the error message to \p message_a */ -nano::error & nano::error::operator= (const std::string message_a) +nano::error & nano::error::operator= (std::string message_a) { code = nano::error_common::generic; message = std::move (message_a); @@ -384,13 +385,13 @@ nano::error & nano::error::operator= (std::exception const & exception_a) } /** Return true if this#error_code equals the parameter */ -bool nano::error::operator== (const std::error_code code_a) const +bool nano::error::operator== (std::error_code const code_a) const { return code == code_a; } /** Return true if this#error_code equals the parameter */ -bool nano::error::operator== (const boost::system::error_code code_a) const +bool nano::error::operator== (boost::system::error_code const code_a) const { return code.value () == code_a.value (); } @@ -461,7 +462,7 @@ nano::error & nano::error::on_error (std::error_code code_a, std::string message /** Set an error message and an error code */ nano::error & nano::error::set (std::string message_a, std::error_code code_a) { - message = message_a; + message = std::move (message_a); code = code_a; return *this; } @@ -485,6 +486,7 @@ nano::error & nano::error::clear () return *this; } +// TODO: theoretically, nothing besides template (partial) specializations should ever be added inside std... namespace std { std::error_code make_error_code (boost::system::errc::errc_t const & e) diff --git a/nano/lib/errors.hpp b/nano/lib/errors.hpp index 4694818fe4..3ec399ccbc 100644 --- a/nano/lib/errors.hpp +++ b/nano/lib/errors.hpp @@ -163,7 +163,7 @@ enum class error_config class enum_type##_messages : public std::error_category \ { \ public: \ - const char * name () const noexcept override \ + char const * name () const noexcept override \ { \ return #enum_type; \ } \ @@ -171,7 +171,7 @@ enum class error_config std::string message (int ev) const override; \ }; \ \ - inline const std::error_category & enum_type##_category () \ + inline std::error_category const & enum_type##_category () \ { \ static enum_type##_messages instance; \ return instance; \ @@ -201,7 +201,7 @@ namespace nano { namespace error_conversion { - const std::error_category & generic_category (); + std::error_category const & generic_category (); } } @@ -224,12 +224,12 @@ namespace error_conversion class generic_category : public std::error_category { public: - const char * name () const noexcept override; + char const * name () const noexcept override; std::string message (int value) const override; }; } - const std::error_category & generic_category (); - std::error_code convert (const boost::system::error_code & error); + std::error_category const & generic_category (); + std::error_code convert (boost::system::error_code const & error); } } @@ -249,13 +249,13 @@ class error error (std::exception const & exception_a); error & operator= (nano::error const & err_a); error & operator= (nano::error && err_a); - error & operator= (const std::error_code code_a); - error & operator= (const boost::system::error_code & code_a); - error & operator= (const boost::system::errc::errc_t & code_a); - error & operator= (const std::string message_a); + error & operator= (std::error_code code_a); + error & operator= (boost::system::error_code const & code_a); + error & operator= (boost::system::errc::errc_t const & code_a); + error & operator= (std::string message_a); error & operator= (std::exception const & exception_a); - bool operator== (const std::error_code code_a) const; - bool operator== (const boost::system::error_code code_a) const; + bool operator== (std::error_code code_a) const; + bool operator== (boost::system::error_code code_a) const; error & then (std::function next); template error & accept (ErrorCode... err) diff --git a/nano/lib/ipc.cpp b/nano/lib/ipc.cpp index 82a7ce2e33..3d870f866c 100644 --- a/nano/lib/ipc.cpp +++ b/nano/lib/ipc.cpp @@ -11,7 +11,7 @@ void nano::ipc::socket_base::timer_start (std::chrono::seconds timeout_a) if (timeout_a < std::chrono::seconds::max ()) { io_timer.expires_from_now (boost::posix_time::seconds (static_cast (timeout_a.count ()))); - io_timer.async_wait ([this] (const boost::system::error_code & ec) { + io_timer.async_wait ([this] (boost::system::error_code const & ec) { if (!ec) { this->timer_expired (); diff --git a/nano/lib/ipc_client.cpp b/nano/lib/ipc_client.cpp index 8be1091a87..073735faa5 100644 --- a/nano/lib/ipc_client.cpp +++ b/nano/lib/ipc_client.cpp @@ -208,7 +208,7 @@ class client_impl : public nano::ipc::ipc_client_impl tcp_client->async_resolve (host_a, port_a, [this, callback_a] (boost::system::error_code const & ec_resolve_a, boost::asio::ip::tcp::endpoint endpoint_a) { if (!ec_resolve_a) { - this->tcp_client->async_connect ([callback_a] (const boost::system::error_code & ec_connect_a) { + this->tcp_client->async_connect ([callback_a] (boost::system::error_code const & ec_connect_a) { callback_a (nano::error (ec_connect_a)); }); } @@ -278,7 +278,7 @@ nano::error nano::ipc::ipc_client::connect (std::string const & host, uint16_t p void nano::ipc::ipc_client::async_write (nano::shared_const_buffer const & buffer_a, std::function callback_a) { auto client (boost::polymorphic_downcast (impl.get ())); - client->get_channel ().async_write (buffer_a, [callback_a] (const boost::system::error_code & ec_a, size_t bytes_written_a) { + client->get_channel ().async_write (buffer_a, [callback_a] (boost::system::error_code const & ec_a, size_t bytes_written_a) { callback_a (nano::error (ec_a), bytes_written_a); }); } @@ -286,7 +286,7 @@ void nano::ipc::ipc_client::async_write (nano::shared_const_buffer const & buffe void nano::ipc::ipc_client::async_read (std::shared_ptr> const & buffer_a, size_t size_a, std::function callback_a) { auto client (boost::polymorphic_downcast (impl.get ())); - client->get_channel ().async_read (buffer_a, size_a, [callback_a, buffer_a] (const boost::system::error_code & ec_a, size_t bytes_read_a) { + client->get_channel ().async_read (buffer_a, size_a, [callback_a, buffer_a] (boost::system::error_code const & ec_a, size_t bytes_read_a) { callback_a (nano::error (ec_a), bytes_read_a); }); } @@ -295,7 +295,7 @@ void nano::ipc::ipc_client::async_read (std::shared_ptr> co void nano::ipc::ipc_client::async_read_message (std::shared_ptr> const & buffer_a, std::chrono::seconds timeout_a, std::function callback_a) { auto client (boost::polymorphic_downcast (impl.get ())); - client->get_channel ().async_read_message (buffer_a, timeout_a, [callback_a, buffer_a] (const boost::system::error_code & ec_a, size_t bytes_read_a) { + client->get_channel ().async_read_message (buffer_a, timeout_a, [callback_a, buffer_a] (boost::system::error_code const & ec_a, size_t bytes_read_a) { callback_a (nano::error (ec_a), bytes_read_a); }); } diff --git a/nano/lib/lmdbconfig.cpp b/nano/lib/lmdbconfig.cpp index 8281b9291b..a4387fcaa8 100644 --- a/nano/lib/lmdbconfig.cpp +++ b/nano/lib/lmdbconfig.cpp @@ -29,19 +29,12 @@ nano::error nano::lmdb_config::serialize_toml (nano::tomlconfig & toml) const return toml.get_error (); } -nano::error nano::lmdb_config::deserialize_toml (nano::tomlconfig & toml, bool is_deprecated_lmdb_dbs_used) +nano::error nano::lmdb_config::deserialize_toml (nano::tomlconfig & toml) { - static nano::network_params params; auto default_max_databases = max_databases; toml.get_optional ("max_databases", max_databases); toml.get_optional ("map_size", map_size); - // For now we accept either setting, but not both - if (!params.network.is_dev_network () && is_deprecated_lmdb_dbs_used && default_max_databases != max_databases) - { - toml.get_error ().set ("Both the deprecated node.lmdb_max_dbs and the new node.lmdb.max_databases setting are used. Please use max_databases only."); - } - if (!toml.get_error ()) { std::string sync_string = "always"; diff --git a/nano/lib/lmdbconfig.hpp b/nano/lib/lmdbconfig.hpp index 4474a835a0..b48f635bd5 100644 --- a/nano/lib/lmdbconfig.hpp +++ b/nano/lib/lmdbconfig.hpp @@ -40,7 +40,7 @@ class lmdb_config final }; nano::error serialize_toml (nano::tomlconfig & toml_a) const; - nano::error deserialize_toml (nano::tomlconfig & toml_a, bool is_deprecated_lmdb_dbs_used); + nano::error deserialize_toml (nano::tomlconfig & toml_a); /** Sync strategy for the ledger database */ sync_strategy sync{ always }; diff --git a/nano/lib/locks.cpp b/nano/lib/locks.cpp index 4473ef379e..56a018b13d 100644 --- a/nano/lib/locks.cpp +++ b/nano/lib/locks.cpp @@ -10,9 +10,9 @@ #if USING_NANO_TIMED_LOCKS namespace nano { -// These mutexes must have std::mutex interface in addition to "const char* get_name ()" method +// These mutexes must have std::mutex interface in addition to "char const * get_name ()" method template -void output (const char * str, std::chrono::milliseconds time, Mutex & mutex) +void output (char const * str, std::chrono::milliseconds time, Mutex & mutex) { static nano::mutex cout_mutex; auto stacktrace = nano::generate_stacktrace (); @@ -232,7 +232,7 @@ void condition_variable::wait (nano::unique_lock & lk) nano::mutex * mutex_to_filter{ nullptr }; nano::mutex mutex_to_filter_mutex; -bool should_be_filtered (const char * name) +bool should_be_filtered (char const * name) { return std::strcmp (name, xstr (NANO_TIMED_LOCKS_FILTER)) == 0; } diff --git a/nano/lib/locks.hpp b/nano/lib/locks.hpp index ef1217b36f..cb490e455c 100644 --- a/nano/lib/locks.hpp +++ b/nano/lib/locks.hpp @@ -14,7 +14,7 @@ namespace nano class mutex; extern nano::mutex * mutex_to_filter; extern nano::mutex mutex_to_filter_mutex; -bool should_be_filtered (const char * name); +bool should_be_filtered (char const * name); bool any_filters_registered (); enum class mutexes @@ -45,7 +45,7 @@ class mutex { public: mutex () = default; - mutex (const char * name_a) + mutex (char const * name_a) #if USING_NANO_TIMED_LOCKS : name (name_a) @@ -90,7 +90,7 @@ class mutex } #if USING_NANO_TIMED_LOCKS - const char * get_name () const + char const * get_name () const { return name ? name : ""; } @@ -98,14 +98,14 @@ class mutex private: #if USING_NANO_TIMED_LOCKS - const char * name{ nullptr }; + char const * name{ nullptr }; #endif std::mutex mutex_m; }; #if USING_NANO_TIMED_LOCKS template -void output (const char * str, std::chrono::milliseconds time, Mutex & mutex); +void output (char const * str, std::chrono::milliseconds time, Mutex & mutex); template void output_if_held_long_enough (nano::timer & timer, Mutex & mutex); diff --git a/nano/lib/logger_mt.hpp b/nano/lib/logger_mt.hpp index eff7d4d297..9afd47842a 100644 --- a/nano/lib/logger_mt.hpp +++ b/nano/lib/logger_mt.hpp @@ -26,7 +26,7 @@ struct severity_tag; inline boost::log::formatting_ostream & operator<< (boost::log::formatting_ostream & strm, boost::log::to_log_manip const & manip) { // Needs to match order in the severity_level enum - static std::array strings = { + static std::array strings = { "", "Error: " }; diff --git a/nano/lib/numbers.cpp b/nano/lib/numbers.cpp index d3f3f87d02..8cb1c0e79d 100644 --- a/nano/lib/numbers.cpp +++ b/nano/lib/numbers.cpp @@ -3,6 +3,7 @@ #include #include #include +#include #include #include @@ -61,6 +62,16 @@ std::string nano::public_key::to_account () const return result; } +nano::public_key::public_key () : + uint256_union{ 0 } +{ +} + +nano::public_key const & nano::public_key::null () +{ + return nano::hardened_constants::get ().not_an_account; +} + std::string nano::public_key::to_node_id () const { return to_account ().replace (0, 4, "node"); @@ -645,7 +656,7 @@ void format_frac (std::ostringstream & stream, nano::uint128_t value, nano::uint } } -void format_dec (std::ostringstream & stream, nano::uint128_t value, char group_sep, const std::string & groupings) +void format_dec (std::ostringstream & stream, nano::uint128_t value, char group_sep, std::string const & groupings) { auto largestPow10 = nano::uint256_t (1); int dec_count = 1; @@ -749,7 +760,7 @@ std::string nano::uint128_union::format_balance (nano::uint128_t scale, int prec return ::format_balance (number (), scale, precision, group_digits, thousands_sep, decimal_point, grouping); } -std::string nano::uint128_union::format_balance (nano::uint128_t scale, int precision, bool group_digits, const std::locale & locale) const +std::string nano::uint128_union::format_balance (nano::uint128_t scale, int precision, bool group_digits, std::locale const & locale) const { auto thousands_sep = std::use_facet> (locale).thousands_sep (); auto decimal_point = std::use_facet> (locale).decimal_point (); @@ -781,6 +792,11 @@ std::string nano::uint128_union::to_string_dec () const return result; } +nano::hash_or_account::hash_or_account () : + account{} +{ +} + nano::hash_or_account::hash_or_account (uint64_t value_a) : raw (value_a) { @@ -939,6 +955,16 @@ nano::public_key::operator nano::hash_or_account const & () const return reinterpret_cast (*this); } +bool nano::public_key::operator== (std::nullptr_t) const +{ + return bytes == null ().bytes; +} + +bool nano::public_key::operator!= (std::nullptr_t) const +{ + return !(*this == nullptr); +} + nano::block_hash::operator nano::link const & () const { return reinterpret_cast (*this); diff --git a/nano/lib/numbers.hpp b/nano/lib/numbers.hpp index 93ab7fd0d5..83153ec7fe 100644 --- a/nano/lib/numbers.hpp +++ b/nano/lib/numbers.hpp @@ -35,7 +35,7 @@ class uint128_union bool decode_dec (std::string const &, bool = false); bool decode_dec (std::string const &, nano::uint128_t); std::string format_balance (nano::uint128_t scale, int precision, bool group_digits) const; - std::string format_balance (nano::uint128_t scale, int precision, bool group_digits, const std::locale & locale) const; + std::string format_balance (nano::uint128_t scale, int precision, bool group_digits, std::locale const & locale) const; nano::uint128_t number () const; void clear (); bool is_zero () const; @@ -66,7 +66,7 @@ class uint256_union * Decode from hex string * @warning Aborts at runtime if the input is invalid */ - uint256_union (std::string const &); + explicit uint256_union (std::string const &); uint256_union (uint64_t); uint256_union (nano::uint256_t const &); void encrypt (nano::raw_key const &, nano::raw_key const &, uint128_union const &); @@ -115,6 +115,10 @@ class public_key final : public uint256_union public: using uint256_union::uint256_union; + public_key (); + + static const public_key & null (); + std::string to_node_id () const; bool decode_node_id (std::string const & source_a); void encode_account (std::string &) const; @@ -124,6 +128,10 @@ class public_key final : public uint256_union operator nano::link const & () const; operator nano::root const & () const; operator nano::hash_or_account const & () const; + bool operator== (std::nullptr_t) const; + bool operator!= (std::nullptr_t) const; + using uint256_union::operator==; + using uint256_union::operator!=; }; class wallet_id : public uint256_union @@ -137,7 +145,7 @@ using account = public_key; class hash_or_account { public: - hash_or_account () = default; + hash_or_account (); hash_or_account (uint64_t value_a); bool is_zero () const; @@ -239,7 +247,7 @@ nano::signature sign_message (nano::raw_key const &, nano::public_key const &, n nano::signature sign_message (nano::raw_key const &, nano::public_key const &, uint8_t const *, size_t); bool validate_message (nano::public_key const &, nano::uint256_union const &, nano::signature const &); bool validate_message (nano::public_key const &, uint8_t const *, size_t, nano::signature const &); -bool validate_message_batch (unsigned const char **, size_t *, unsigned const char **, unsigned const char **, size_t, int *); +bool validate_message_batch (unsigned char const **, size_t *, unsigned char const **, unsigned char const **, size_t, int *); nano::raw_key deterministic_key (nano::raw_key const &, uint32_t); nano::public_key pub_key (nano::raw_key const &); diff --git a/nano/lib/plat/linux/debugging.cpp b/nano/lib/plat/linux/debugging.cpp index f0a596cf68..caee1b910e 100644 --- a/nano/lib/plat/linux/debugging.cpp +++ b/nano/lib/plat/linux/debugging.cpp @@ -16,13 +16,13 @@ int create_load_memory_address_file (dl_phdr_info * info, size_t, void *) static int counter = 0; debug_assert (counter <= 99); // Create filename - const char file_prefix[] = "nano_node_crash_load_address_dump_"; + char const file_prefix[] = "nano_node_crash_load_address_dump_"; // Holds the filename prefix, a unique (max 2 digits) number and extension (null terminator is included in file_prefix size) char filename[sizeof (file_prefix) + 2 + 4]; snprintf (filename, sizeof (filename), "%s%d.txt", file_prefix, counter); // Open file - const auto file_descriptor = ::open (filename, O_CREAT | O_WRONLY | O_TRUNC, + auto const file_descriptor = ::open (filename, O_CREAT | O_WRONLY | O_TRUNC, #if defined(S_IWRITE) && defined(S_IREAD) S_IWRITE | S_IREAD #else diff --git a/nano/lib/rep_weights.cpp b/nano/lib/rep_weights.cpp index efdccc598d..17968e7863 100644 --- a/nano/lib/rep_weights.cpp +++ b/nano/lib/rep_weights.cpp @@ -1,5 +1,5 @@ #include -#include +#include void nano::rep_weights::representation_add (nano::account const & source_rep_a, nano::uint128_t const & amount_a) { diff --git a/nano/lib/rep_weights.hpp b/nano/lib/rep_weights.hpp index cce5140497..4647dd2a97 100644 --- a/nano/lib/rep_weights.hpp +++ b/nano/lib/rep_weights.hpp @@ -9,7 +9,7 @@ namespace nano { -class block_store; +class store; class transaction; class rep_weights @@ -28,8 +28,8 @@ class rep_weights void put (nano::account const & account_a, nano::uint128_union const & representation_a); nano::uint128_t get (nano::account const & account_a) const; - friend std::unique_ptr collect_container_info (rep_weights const &, const std::string &); + friend std::unique_ptr collect_container_info (rep_weights const &, std::string const &); }; -std::unique_ptr collect_container_info (rep_weights const &, const std::string &); +std::unique_ptr collect_container_info (rep_weights const &, std::string const &); } diff --git a/nano/lib/rocksdbconfig.cpp b/nano/lib/rocksdbconfig.cpp index fb090ca41f..e1ec644b6f 100644 --- a/nano/lib/rocksdbconfig.cpp +++ b/nano/lib/rocksdbconfig.cpp @@ -1,3 +1,4 @@ +#include #include #include @@ -27,3 +28,9 @@ nano::error nano::rocksdb_config::deserialize_toml (nano::tomlconfig & toml) return toml.get_error (); } + +bool nano::rocksdb_config::using_rocksdb_in_tests () +{ + auto use_rocksdb_str = std::getenv ("TEST_USE_ROCKSDB"); + return use_rocksdb_str && (boost::lexical_cast (use_rocksdb_str) == 1); +} diff --git a/nano/lib/rocksdbconfig.hpp b/nano/lib/rocksdbconfig.hpp index 750eab9d5d..ff185ada0e 100644 --- a/nano/lib/rocksdbconfig.hpp +++ b/nano/lib/rocksdbconfig.hpp @@ -12,9 +12,16 @@ class tomlconfig; class rocksdb_config final { public: + rocksdb_config () : + enable{ using_rocksdb_in_tests () } + { + } nano::error serialize_toml (nano::tomlconfig & toml_a) const; nano::error deserialize_toml (nano::tomlconfig & toml_a); + /** To use RocksDB in tests make sure the environment variable TEST_USE_ROCKSDB=1 is set */ + static bool using_rocksdb_in_tests (); + bool enable{ false }; uint8_t memory_multiplier{ 2 }; unsigned io_threads{ std::thread::hardware_concurrency () }; diff --git a/nano/lib/rpcconfig.cpp b/nano/lib/rpcconfig.cpp index 7f734e3c23..b7d1e7855e 100644 --- a/nano/lib/rpcconfig.cpp +++ b/nano/lib/rpcconfig.cpp @@ -54,15 +54,17 @@ nano::error nano::rpc_secure_config::deserialize_toml (nano::tomlconfig & toml) return toml.get_error (); } -nano::rpc_config::rpc_config () : - address (boost::asio::ip::address_v6::loopback ().to_string ()) +nano::rpc_config::rpc_config (nano::network_constants & network_constants) : + rpc_process{ network_constants }, + address{ boost::asio::ip::address_v6::loopback ().to_string () } { } -nano::rpc_config::rpc_config (uint16_t port_a, bool enable_control_a) : - address (boost::asio::ip::address_v6::loopback ().to_string ()), - port (port_a), - enable_control (enable_control_a) +nano::rpc_config::rpc_config (nano::network_constants & network_constants, uint16_t port_a, bool enable_control_a) : + rpc_process{ network_constants }, + address{ boost::asio::ip::address_v6::loopback ().to_string () }, + port{ port_a }, + enable_control{ enable_control_a } { } @@ -151,7 +153,7 @@ nano::error nano::rpc_config::deserialize_toml (nano::tomlconfig & toml) auto rpc_secure_l (toml.get_optional_child ("secure")); if (rpc_secure_l) { - secure.deserialize_toml (*rpc_secure_l); + return nano::error ("The RPC secure configuration has moved to config-tls.toml. Please update the configuration."); } boost::asio::ip::address_v6 address_l; @@ -183,8 +185,9 @@ nano::error nano::rpc_config::deserialize_toml (nano::tomlconfig & toml) return toml.get_error (); } -nano::rpc_process_config::rpc_process_config () : - ipc_address (boost::asio::ip::address_v6::loopback ().to_string ()) +nano::rpc_process_config::rpc_process_config (nano::network_constants & network_constants) : + network_constants{ network_constants }, + ipc_address{ boost::asio::ip::address_v6::loopback ().to_string () } { } @@ -206,7 +209,7 @@ nano::error read_rpc_config_toml (boost::filesystem::path const & data_path_a, n else { // Migrate - nano::rpc_config config_json_l; + nano::rpc_config config_json_l{ config_a.rpc_process.network_constants }; error = read_and_update_rpc_config (data_path_a, config_json_l); if (!error) @@ -215,7 +218,7 @@ nano::error read_rpc_config_toml (boost::filesystem::path const & data_path_a, n config_json_l.serialize_toml (toml_l); // Only write out non-default values - nano::rpc_config config_defaults_l; + nano::rpc_config config_defaults_l{ config_a.rpc_process.network_constants }; nano::tomlconfig toml_defaults_l; config_defaults_l.serialize_toml (toml_defaults_l); diff --git a/nano/lib/rpcconfig.hpp b/nano/lib/rpcconfig.hpp index 4a9a3e9462..bd112b5229 100644 --- a/nano/lib/rpcconfig.hpp +++ b/nano/lib/rpcconfig.hpp @@ -3,6 +3,7 @@ #include #include +#include #include #include #include @@ -19,8 +20,12 @@ namespace nano { class jsonconfig; class tomlconfig; +class tls_config; -/** Configuration options for RPC TLS */ +/** + * Configuration options for RPC TLS. + * @note This is deprecated, but kept for a few versions in order to yield a config error message on startup if it's used. + */ class rpc_secure_config final { public: @@ -29,6 +34,7 @@ class rpc_secure_config final nano::error serialize_toml (nano::tomlconfig &) const; nano::error deserialize_toml (nano::tomlconfig &); +private: /** If true, enable TLS */ bool enable{ false }; /** If true, log certificate verification details */ @@ -48,12 +54,13 @@ class rpc_secure_config final class rpc_process_config final { public: - rpc_process_config (); - nano::network_constants network_constants; + rpc_process_config (nano::network_constants & network_constants); + nano::network_constants & network_constants; unsigned io_threads{ (4 < std::thread::hardware_concurrency ()) ? std::thread::hardware_concurrency () : 4 }; std::string ipc_address; uint16_t ipc_port{ network_constants.default_ipc_port }; - unsigned num_ipc_connections{ (network_constants.is_live_network () || network_constants.is_test_network ()) ? 8u : network_constants.is_beta_network () ? 4u : 1u }; + unsigned num_ipc_connections{ (network_constants.is_live_network () || network_constants.is_test_network ()) ? 8u : network_constants.is_beta_network () ? 4u + : 1u }; static unsigned json_version () { return 1; @@ -69,8 +76,8 @@ class rpc_logging_config final class rpc_config final { public: - rpc_config (); - explicit rpc_config (uint16_t, bool); + explicit rpc_config (nano::network_constants & network_constants); + explicit rpc_config (nano::network_constants & network_constants, uint16_t, bool); nano::error serialize_json (nano::jsonconfig &) const; nano::error deserialize_json (bool & upgraded_a, nano::jsonconfig &); nano::error serialize_toml (nano::tomlconfig &) const; @@ -84,6 +91,8 @@ class rpc_config final uint8_t max_json_depth{ 20 }; uint64_t max_request_size{ 32 * 1024 * 1024 }; nano::rpc_logging_config rpc_logging; + /** Optional TLS config */ + std::shared_ptr tls_config; static unsigned json_version () { return 1; diff --git a/nano/lib/signal_manager.cpp b/nano/lib/signal_manager.cpp index ffaae2d425..365b37142c 100644 --- a/nano/lib/signal_manager.cpp +++ b/nano/lib/signal_manager.cpp @@ -42,22 +42,14 @@ void nano::signal_manager::register_signal_handler (int signum, std::functionasync_wait ([descriptor] (const boost::system::error_code & error, int signum) { + sigset->async_wait ([descriptor] (boost::system::error_code const & error, int signum) { nano::signal_manager::base_handler (descriptor, error, signum); }); log (boost::str (boost::format ("Registered signal handler for signal %d") % signum)); } -std::function nano::signal_manager::get_debug_files_handler (void) -{ - return [] (int) { - nano::dump_crash_stacktrace (); - nano::create_load_memory_address_files (); - }; -} - -void nano::signal_manager::base_handler (nano::signal_manager::signal_descriptor descriptor, const boost::system::error_code & error, int signum) +void nano::signal_manager::base_handler (nano::signal_manager::signal_descriptor descriptor, boost::system::error_code const & error, int signum) { if (!error) { @@ -72,7 +64,7 @@ void nano::signal_manager::base_handler (nano::signal_manager::signal_descriptor // continue asynchronously listening for signals from this signal set if (descriptor.repeat) { - descriptor.sigset->async_wait ([descriptor] (const boost::system::error_code & error, int signum) { + descriptor.sigset->async_wait ([descriptor] (boost::system::error_code const & error, int signum) { nano::signal_manager::base_handler (descriptor, error, signum); }); } diff --git a/nano/lib/signal_manager.hpp b/nano/lib/signal_manager.hpp index b667ae561f..5012de52fb 100644 --- a/nano/lib/signal_manager.hpp +++ b/nano/lib/signal_manager.hpp @@ -33,9 +33,6 @@ class signal_manager final */ void register_signal_handler (int signum, std::function handler, bool repeat); - /** returns a signal handler that prints a stacktrace and creates some debug files */ - std::function get_debug_files_handler (void); - private: struct signal_descriptor final { @@ -64,7 +61,7 @@ class signal_manager final * This is the actual handler that is registered with boost asio. * It calls the caller supplied function (if one is given) and sets the handler to repeat (or not). */ - static void base_handler (nano::signal_manager::signal_descriptor descriptor, const boost::system::error_code & error, int signum); + static void base_handler (nano::signal_manager::signal_descriptor descriptor, boost::system::error_code const & error, int signum); /** boost asio context to use */ boost::asio::io_context ioc; diff --git a/nano/lib/stats.cpp b/nano/lib/stats.cpp index 0b02dec981..a2ede29b73 100644 --- a/nano/lib/stats.cpp +++ b/nano/lib/stats.cpp @@ -616,6 +616,9 @@ std::string nano::stat::detail_to_string (uint32_t key) case nano::stat::detail::error_socket_close: res = "error_socket_close"; break; + case nano::stat::detail::request_underflow: + res = "request_underflow"; + break; case nano::stat::detail::change: res = "change"; break; @@ -775,6 +778,15 @@ std::string nano::stat::detail_to_string (uint32_t key) case nano::stat::detail::tcp_max_per_ip: res = "tcp_max_per_ip"; break; + case nano::stat::detail::tcp_max_per_subnetwork: + res = "tcp_max_per_subnetwork"; + break; + case nano::stat::detail::tcp_silent_connection_drop: + res = "tcp_silent_connection_drop"; + break; + case nano::stat::detail::tcp_io_timeout_drop: + res = "tcp_io_timeout_drop"; + break; case nano::stat::detail::unreachable_host: res = "unreachable_host"; break; @@ -808,6 +820,12 @@ std::string nano::stat::detail_to_string (uint32_t key) case nano::stat::detail::outdated_version: res = "outdated_version"; break; + case nano::stat::detail::udp_max_per_ip: + res = "udp_max_per_ip"; + break; + case nano::stat::detail::udp_max_per_subnetwork: + res = "udp_max_per_subnetwork"; + break; case nano::stat::detail::blocks_confirmed: res = "blocks_confirmed"; break; @@ -883,6 +901,9 @@ std::string nano::stat::detail_to_string (uint32_t key) case nano::stat::detail::generator_spacing: res = "generator_spacing"; break; + case nano::stat::detail::invalid_network: + res = "invalid_network"; + break; } return res; } diff --git a/nano/lib/stats.hpp b/nano/lib/stats.hpp index 9a72089e66..4e4e9a3a19 100644 --- a/nano/lib/stats.hpp +++ b/nano/lib/stats.hpp @@ -255,6 +255,7 @@ class stat final insufficient_work, http_callback, unreachable_host, + invalid_network, // confirmation_observer specific active_quorum, @@ -302,6 +303,7 @@ class stat final frontier_confirmation_failed, frontier_confirmation_successful, error_socket_close, + request_underflow, // vote specific vote_valid, @@ -336,6 +338,8 @@ class stat final invalid_telemetry_req_message, invalid_telemetry_ack_message, outdated_version, + udp_max_per_ip, + udp_max_per_subnetwork, // tcp tcp_accept_success, @@ -344,6 +348,9 @@ class stat final tcp_write_no_socket_drop, tcp_excluded, tcp_max_per_ip, + tcp_max_per_subnetwork, + tcp_silent_connection_drop, + tcp_io_timeout_drop, // ipc invocations, diff --git a/nano/lib/threading.cpp b/nano/lib/threading.cpp index df17fda901..809f0009c2 100644 --- a/nano/lib/threading.cpp +++ b/nano/lib/threading.cpp @@ -123,8 +123,7 @@ nano::thread_runner::thread_runner (boost::asio::io_context & io_ctx_a, unsigned { boost::thread::attributes attrs; nano::thread_attributes::set (attrs); - auto count = (is_sanitizer_build && nano::network_constants{}.is_dev_network ()) ? 1 : service_threads_a; // This is a workaround to a bad interaction between TSAN, multiple coroutines, and multiple threads servicing io_context. Only use 1 thread if sanitizers are attached - for (auto i (0u); i < count; ++i) + for (auto i (0u); i < service_threads_a; ++i) { threads.emplace_back (attrs, [&io_ctx_a] () { nano::thread_role::set (nano::thread_role::name::io); @@ -244,7 +243,7 @@ void nano::thread_pool::add_timed_task (std::chrono::steady_clock::time_point co if (!stopped && thread_pool_m) { auto timer = std::make_shared (thread_pool_m->get_executor (), expiry_time); - timer->async_wait ([this, task, timer] (const boost::system::error_code & ec) { + timer->async_wait ([this, task, timer] (boost::system::error_code const & ec) { if (!ec) { push_task (task); diff --git a/nano/lib/threading.hpp b/nano/lib/threading.hpp index dd7112bd90..5180880e98 100644 --- a/nano/lib/threading.hpp +++ b/nano/lib/threading.hpp @@ -9,6 +9,8 @@ #include +#include + namespace nano { /* diff --git a/nano/lib/tlsconfig.cpp b/nano/lib/tlsconfig.cpp new file mode 100644 index 0000000000..d16efcfa31 --- /dev/null +++ b/nano/lib/tlsconfig.cpp @@ -0,0 +1,188 @@ +#include +#include +#include +#include + +#include + +#include + +namespace nano +{ +nano::error nano::tls_config::serialize_toml (nano::tomlconfig & toml) const +{ + toml.put ("enable_https", enable_https, "Enable or disable https:// support.\ntype:bool"); + toml.put ("enable_wss", enable_wss, "Enable or disable wss:// support.\ntype:bool"); + toml.put ("verbose_logging", verbose_logging, "Enable or disable verbose TLS logging.\ntype:bool"); + toml.put ("server_key_passphrase", server_key_passphrase, "Server key passphrase.\ntype:string"); + toml.put ("server_cert_path", server_cert_path, "Directory containing certificates.\ntype:string,path"); + toml.put ("server_key_path", server_key_path, "Path to server key PEM file.\ntype:string,path"); + toml.put ("server_dh_path", server_dh_path, "Path to Diffie-Hellman params file.\ntype:string,path"); + toml.put ("client_certs_path", client_certs_path, "Directory containing optional client certificates.\ntype:string,path"); + return toml.get_error (); +} + +nano::error nano::tls_config::deserialize_toml (nano::tomlconfig & toml) +{ + toml.get ("enable_https", enable_https); + toml.get ("enable_wss", enable_wss); + toml.get ("verbose_logging", verbose_logging); + toml.get ("server_key_passphrase", server_key_passphrase); + toml.get ("server_cert_path", server_cert_path); + toml.get ("server_key_path", server_key_path); + toml.get ("server_dh_path", server_dh_path); + toml.get ("client_certs_path", client_certs_path); + return toml.get_error (); +} + +#ifdef NANO_SECURE_RPC +namespace +{ + bool on_verify_certificate (bool preverified, boost::asio::ssl::verify_context & ctx, nano::tls_config & config_a, nano::logger_mt & logger_a) + { + X509_STORE_CTX * cts = ctx.native_handle (); + auto error (X509_STORE_CTX_get_error (cts)); + switch (error) + { + case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT: + logger_a.always_log ("TLS: Unable to get issuer"); + break; + case X509_V_ERR_CERT_NOT_YET_VALID: + case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD: + logger_a.always_log ("TLS: Certificate not yet valid"); + break; + case X509_V_ERR_CERT_HAS_EXPIRED: + case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD: + logger_a.always_log ("TLS: Certificate expired"); + break; + case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN: + if (config_a.verbose_logging) + { + logger_a.always_log ("TLS: Self-signed certificate in chain"); + } + + // Allow self-signed certificates + preverified = true; + break; + case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT: + logger_a.always_log ("TLS: Self-signed certificate not in the list of trusted certs (forgot to subject-hash certificate filename?)"); + break; + default: + break; + } + + if (config_a.verbose_logging) + { + if (error != 0) + { + logger_a.always_log ("TLS: Error: ", X509_verify_cert_error_string (error)); + logger_a.always_log ("TLS: Error chain depth : ", X509_STORE_CTX_get_error_depth (cts)); + } + + X509 * cert = X509_STORE_CTX_get_current_cert (cts); + char subject_name[512]; + X509_NAME_oneline (X509_get_subject_name (cert), subject_name, sizeof (subject_name) - 1); + logger_a.always_log ("TLS: Verifying: ", subject_name); + logger_a.always_log ("TLS: Verification: ", preverified); + } + else if (!preverified) + { + logger_a.always_log ("TLS: Pre-verification failed. Turn on verbose logging for more information."); + } + + return preverified; + } + + void load_certs (nano::tls_config & config_a, nano::logger_mt & logger_a) + { + try + { + // This is called if the key is password protected + config_a.ssl_context.set_password_callback ( + [&config_a] (std::size_t, + boost::asio::ssl::context_base::password_purpose) { + return config_a.server_key_passphrase; + }); + + // The following two options disables the session cache and enables stateless session resumption. + // This is necessary because of the way the RPC server abruptly terminate connections. + SSL_CTX_set_session_cache_mode (config_a.ssl_context.native_handle (), SSL_SESS_CACHE_OFF); + SSL_CTX_set_options (config_a.ssl_context.native_handle (), SSL_OP_NO_TICKET); + + config_a.ssl_context.set_options ( + boost::asio::ssl::context::default_workarounds | boost::asio::ssl::context::no_sslv2 | boost::asio::ssl::context::no_sslv3 | boost::asio::ssl::context::single_dh_use); + + config_a.ssl_context.use_certificate_chain_file (config_a.server_cert_path); + config_a.ssl_context.use_private_key_file (config_a.server_key_path, boost::asio::ssl::context::pem); + config_a.ssl_context.use_tmp_dh_file (config_a.server_dh_path); + + // Verify client certificates? + if (!config_a.client_certs_path.empty ()) + { + config_a.ssl_context.set_verify_mode (boost::asio::ssl::verify_fail_if_no_peer_cert | boost::asio::ssl::verify_peer); + config_a.ssl_context.add_verify_path (config_a.client_certs_path); + config_a.ssl_context.set_verify_callback ([&config_a, &logger_a] (auto preverified, auto & ctx) { + return on_verify_certificate (preverified, ctx, config_a, logger_a); + }); + } + + logger_a.always_log ("TLS: successfully configured"); + } + catch (boost::system::system_error const & err) + { + auto error (boost::str (boost::format ("Could not load certificate information: %1%. Make sure the paths and the passphrase in config-tls.toml are correct.") % err.what ())); + std::cerr << error << std::endl; + logger_a.always_log (error); + } + } +} +#endif + +nano::error read_tls_config_toml (boost::filesystem::path const & data_path_a, nano::tls_config & config_a, nano::logger_mt & logger_a, std::vector const & config_overrides) +{ + nano::error error; + auto toml_config_path = nano::get_tls_toml_config_path (data_path_a); + + // Parse and deserialize + nano::tomlconfig toml; + + std::stringstream config_overrides_stream; + for (auto const & entry : config_overrides) + { + config_overrides_stream << entry << std::endl; + } + config_overrides_stream << std::endl; + + // Make sure we don't create an empty toml file if it doesn't exist. Running without a tls toml file is the default. + if (!error) + { + if (boost::filesystem::exists (toml_config_path)) + { + error = toml.read (config_overrides_stream, toml_config_path); + } + else + { + error = toml.read (config_overrides_stream); + } + } + + if (!error) + { + error = config_a.deserialize_toml (toml); + } + + if (!error && (config_a.enable_https || config_a.enable_wss)) + { +#ifdef NANO_SECURE_RPC + load_certs (config_a, logger_a); +#else + auto msg ("https or wss is enabled in the TLS configuration, but the node is not built with NANO_SECURE_RPC"); + std::cerr << msg << std::endl; + logger_a.always_log (msg); + std::exit (1); +#endif + } + + return error; +} +} diff --git a/nano/lib/tlsconfig.hpp b/nano/lib/tlsconfig.hpp new file mode 100644 index 0000000000..cd869ed619 --- /dev/null +++ b/nano/lib/tlsconfig.hpp @@ -0,0 +1,63 @@ +#pragma once + +#include +#include + +#include +#include +#include + +#ifdef NANO_SECURE_RPC +#include +#endif + +namespace boost::filesystem +{ +class path; +} + +namespace nano +{ +class logger_mt; +class jsonconfig; +class tomlconfig; + +/** Configuration options for secure RPC and WebSocket connections */ +class tls_config final +{ +public: + nano::error serialize_toml (nano::tomlconfig &) const; + nano::error deserialize_toml (nano::tomlconfig &); + + /** If true, enable TLS for RPC (only allow https, otherwise only allow http) */ + bool enable_https{ false }; + + /** If true, enable TLS for WebSocket (only allow wss, otherwise only allow ws) */ + bool enable_wss{ false }; + + /** If true, log certificate verification details */ + bool verbose_logging{ false }; + + /** Must be set if the private key PEM is password protected */ + std::string server_key_passphrase; + + /** Path to certificate- or chain file. Must be PEM formatted. */ + std::string server_cert_path; + + /** Path to private key file. Must be PEM formatted.*/ + std::string server_key_path; + + /** Path to dhparam file */ + std::string server_dh_path; + + /** Optional path to directory containing client certificates */ + std::string client_certs_path; + +#ifdef NANO_SECURE_RPC + /** The context needs to be shared between sessions to make resumption work */ + boost::asio::ssl::context ssl_context{ boost::asio::ssl::context::tlsv12_server }; +#endif +}; + +nano::error read_tls_config_toml (boost::filesystem::path const & data_path_a, nano::tls_config & config_a, nano::logger_mt & logger_a, std::vector const & config_overrides = std::vector ()); +} diff --git a/nano/lib/tomlconfig.cpp b/nano/lib/tomlconfig.cpp index 12cea9b3de..8d906f568d 100644 --- a/nano/lib/tomlconfig.cpp +++ b/nano/lib/tomlconfig.cpp @@ -152,7 +152,7 @@ nano::tomlconfig & nano::tomlconfig::erase (std::string const & key_a) return *this; } -std::shared_ptr nano::tomlconfig::create_array (std::string const & key, boost::optional documentation_a) +std::shared_ptr nano::tomlconfig::create_array (std::string const & key, boost::optional documentation_a) { if (!has_key (key)) { diff --git a/nano/lib/tomlconfig.hpp b/nano/lib/tomlconfig.hpp index 20c03e6062..e4d6dcfbc2 100644 --- a/nano/lib/tomlconfig.hpp +++ b/nano/lib/tomlconfig.hpp @@ -46,14 +46,14 @@ class tomlconfig : public nano::configbase tomlconfig & replace_child (std::string const & key_a, nano::tomlconfig & conf_a); bool has_key (std::string const & key_a); tomlconfig & erase (std::string const & key_a); - std::shared_ptr create_array (std::string const & key, boost::optional documentation_a); + std::shared_ptr create_array (std::string const & key, boost::optional documentation_a); void erase_default_values (tomlconfig & defaults_a); std::string to_string (); std::string to_string_commented_entries (); /** Set value for the given key. Any existing value will be overwritten. */ template - tomlconfig & put (std::string const & key, T const & value, boost::optional documentation_a = boost::none) + tomlconfig & put (std::string const & key, T const & value, boost::optional documentation_a = boost::none) { tree->insert (key, value); if (documentation_a) diff --git a/nano/lib/utility.cpp b/nano/lib/utility.cpp index 53d9bbaf20..64111b4c41 100644 --- a/nano/lib/utility.cpp +++ b/nano/lib/utility.cpp @@ -5,6 +5,13 @@ #include #include + +#ifdef _WIN32 +#ifndef NOMINMAX +#define NOMINMAX +#endif +#endif + #include #include #include @@ -37,7 +44,7 @@ std::size_t nano::get_file_descriptor_limit () { - std::size_t fd_limit = (std::numeric_limits::max) (); + std::size_t fd_limit = std::numeric_limits::max (); #ifndef _WIN32 rlimit limit{}; if (getrlimit (RLIMIT_NOFILE, &limit) == 0) @@ -87,12 +94,12 @@ void nano::container_info_composite::add_component (std::unique_ptr> & nano::container_info_composite::get_children () const +std::vector> const & nano::container_info_composite::get_children () const { return children; } -const std::string & nano::container_info_composite::get_name () const +std::string const & nano::container_info_composite::get_name () const { return name; } @@ -107,7 +114,7 @@ bool nano::container_info_leaf::is_composite () const return false; } -const nano::container_info & nano::container_info_leaf::get_info () const +nano::container_info const & nano::container_info_leaf::get_info () const { return info; } @@ -152,7 +159,7 @@ void nano::move_all_files_to_dir (boost::filesystem::path const & from, boost::f /* * Backing code for "release_assert" & "debug_assert", which are macros */ -void assert_internal (const char * check_expr, const char * func, const char * file, unsigned int line, bool is_release_assert, std::string_view error_msg) +void assert_internal (char const * check_expr, char const * func, char const * file, unsigned int line, bool is_release_assert, std::string_view error_msg) { std::cerr << "Assertion (" << check_expr << ") failed\n" << func << "\n" diff --git a/nano/lib/utility.hpp b/nano/lib/utility.hpp index c4157b2c48..eb0d1e7111 100644 --- a/nano/lib/utility.hpp +++ b/nano/lib/utility.hpp @@ -24,7 +24,7 @@ namespace system } } -void assert_internal (const char * check_expr, const char * func, const char * file, unsigned int line, bool is_release_assert, std::string_view error = ""); +void assert_internal (char const * check_expr, char const * func, char const * file, unsigned int line, bool is_release_assert, std::string_view error = ""); #define release_assert_1(check) check ? (void)0 : assert_internal (#check, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__, true) #define release_assert_2(check, error_msg) check ? (void)0 : assert_internal (#check, BOOST_CURRENT_FUNCTION, __FILE__, __LINE__, true, error_msg) @@ -76,8 +76,8 @@ class container_info_composite : public container_info_component container_info_composite (std::string const & name); bool is_composite () const override; void add_component (std::unique_ptr child); - const std::vector> & get_children () const; - const std::string & get_name () const; + std::vector> const & get_children () const; + std::string const & get_name () const; private: std::string name; @@ -89,7 +89,7 @@ class container_info_leaf : public container_info_component public: container_info_leaf (container_info const & info); bool is_composite () const override; - const container_info & get_info () const; + container_info const & get_info () const; private: container_info info; diff --git a/nano/lib/walletconfig.hpp b/nano/lib/walletconfig.hpp index 68f9fcc1df..6a04206a90 100644 --- a/nano/lib/walletconfig.hpp +++ b/nano/lib/walletconfig.hpp @@ -19,6 +19,6 @@ class wallet_config final nano::error serialize_toml (nano::tomlconfig & toml_a) const; nano::error deserialize_toml (nano::tomlconfig & toml_a); nano::wallet_id wallet; - nano::account account{ 0 }; + nano::account account{}; }; } diff --git a/nano/lib/work.cpp b/nano/lib/work.cpp index 6ccf06174e..f6afc6ca39 100644 --- a/nano/lib/work.cpp +++ b/nano/lib/work.cpp @@ -22,183 +22,8 @@ std::string nano::to_string (nano::work_version const version_a) return result; } -bool nano::work_validate_entry (nano::block const & block_a) -{ - return block_a.difficulty () < nano::work_threshold_entry (block_a.work_version (), block_a.type ()); -} - -bool nano::work_validate_entry (nano::work_version const version_a, nano::root const & root_a, uint64_t const work_a) -{ - return nano::work_difficulty (version_a, root_a, work_a) < nano::work_threshold_entry (version_a, nano::block_type::state); -} - -uint64_t nano::work_difficulty (nano::work_version const version_a, nano::root const & root_a, uint64_t const work_a) -{ - uint64_t result{ 0 }; - switch (version_a) - { - case nano::work_version::work_1: - result = nano::work_v1::value (root_a, work_a); - break; - default: - debug_assert (false && "Invalid version specified to work_difficulty"); - } - return result; -} - -uint64_t nano::work_threshold_base (nano::work_version const version_a) -{ - uint64_t result{ std::numeric_limits::max () }; - switch (version_a) - { - case nano::work_version::work_1: - result = nano::work_v1::threshold_base (); - break; - default: - debug_assert (false && "Invalid version specified to work_threshold_base"); - } - return result; -} - -uint64_t nano::work_threshold_entry (nano::work_version const version_a, nano::block_type const type_a) -{ - uint64_t result{ std::numeric_limits::max () }; - if (type_a == nano::block_type::state) - { - switch (version_a) - { - case nano::work_version::work_1: - result = nano::work_v1::threshold_entry (); - break; - default: - debug_assert (false && "Invalid version specified to work_threshold_entry"); - } - } - else - { - static nano::network_constants network_constants; - result = network_constants.publish_thresholds.epoch_1; - } - return result; -} - -uint64_t nano::work_threshold (nano::work_version const version_a, nano::block_details const details_a) -{ - uint64_t result{ std::numeric_limits::max () }; - switch (version_a) - { - case nano::work_version::work_1: - result = nano::work_v1::threshold (details_a); - break; - default: - debug_assert (false && "Invalid version specified to ledger work_threshold"); - } - return result; -} - -uint64_t nano::work_v1::threshold_base () -{ - static nano::network_constants network_constants; - return network_constants.publish_thresholds.base; -} - -uint64_t nano::work_v1::threshold_entry () -{ - static nano::network_constants network_constants; - return network_constants.publish_thresholds.entry; -} - -uint64_t nano::work_v1::threshold (nano::block_details const details_a) -{ - static_assert (nano::epoch::max == nano::epoch::epoch_2, "work_v1::threshold is ill-defined"); - static nano::network_constants network_constants; - - uint64_t result{ std::numeric_limits::max () }; - switch (details_a.epoch) - { - case nano::epoch::epoch_2: - result = (details_a.is_receive || details_a.is_epoch) ? network_constants.publish_thresholds.epoch_2_receive : network_constants.publish_thresholds.epoch_2; - break; - case nano::epoch::epoch_1: - case nano::epoch::epoch_0: - result = network_constants.publish_thresholds.epoch_1; - break; - default: - debug_assert (false && "Invalid epoch specified to work_v1 ledger work_threshold"); - } - return result; -} - -#ifndef NANO_FUZZER_TEST -uint64_t nano::work_v1::value (nano::root const & root_a, uint64_t work_a) -{ - uint64_t result; - blake2b_state hash; - blake2b_init (&hash, sizeof (result)); - blake2b_update (&hash, reinterpret_cast (&work_a), sizeof (work_a)); - blake2b_update (&hash, root_a.bytes.data (), root_a.bytes.size ()); - blake2b_final (&hash, reinterpret_cast (&result), sizeof (result)); - return result; -} -#else -uint64_t nano::work_v1::value (nano::root const & root_a, uint64_t work_a) -{ - static nano::network_constants network_constants; - if (!network_constants.is_dev_network ()) - { - debug_assert (false); - std::exit (1); - } - return network_constants.publish_thresholds.base + 1; -} -#endif - -double nano::normalized_multiplier (double const multiplier_a, uint64_t const threshold_a) -{ - static nano::network_constants network_constants; - debug_assert (multiplier_a >= 1); - auto multiplier (multiplier_a); - /* Normalization rules - ratio = multiplier of max work threshold (send epoch 2) from given threshold - i.e. max = 0xfe00000000000000, given = 0xf000000000000000, ratio = 8.0 - normalized = (multiplier + (ratio - 1)) / ratio; - Epoch 1 - multiplier | normalized - 1.0 | 1.0 - 9.0 | 2.0 - 25.0 | 4.0 - Epoch 2 (receive / epoch subtypes) - multiplier | normalized - 1.0 | 1.0 - 65.0 | 2.0 - 241.0 | 4.0 - */ - if (threshold_a == network_constants.publish_thresholds.epoch_1 || threshold_a == network_constants.publish_thresholds.epoch_2_receive) - { - auto ratio (nano::difficulty::to_multiplier (network_constants.publish_thresholds.epoch_2, threshold_a)); - debug_assert (ratio >= 1); - multiplier = (multiplier + (ratio - 1.0)) / ratio; - debug_assert (multiplier >= 1); - } - return multiplier; -} - -double nano::denormalized_multiplier (double const multiplier_a, uint64_t const threshold_a) -{ - static nano::network_constants network_constants; - debug_assert (multiplier_a >= 1); - auto multiplier (multiplier_a); - if (threshold_a == network_constants.publish_thresholds.epoch_1 || threshold_a == network_constants.publish_thresholds.epoch_2_receive) - { - auto ratio (nano::difficulty::to_multiplier (network_constants.publish_thresholds.epoch_2, threshold_a)); - debug_assert (ratio >= 1); - multiplier = multiplier * ratio + 1.0 - ratio; - debug_assert (multiplier >= 1); - } - return multiplier; -} - -nano::work_pool::work_pool (unsigned max_threads_a, std::chrono::nanoseconds pow_rate_limiter_a, std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> opencl_a) : +nano::work_pool::work_pool (nano::network_constants & network_constants, unsigned max_threads_a, std::chrono::nanoseconds pow_rate_limiter_a, std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> opencl_a) : + network_constants{ network_constants }, ticket (0), done (false), pow_rate_limiter (pow_rate_limiter_a), @@ -265,7 +90,7 @@ void nano::work_pool::loop (uint64_t thread) if (opt_work.is_initialized ()) { work = *opt_work; - output = nano::work_v1::value (current_l.item, work); + output = network_constants.work.value (current_l.item, work); } else { @@ -298,7 +123,7 @@ void nano::work_pool::loop (uint64_t thread) { // If the ticket matches what we started with, we're the ones that found the solution debug_assert (output >= current_l.difficulty); - debug_assert (current_l.difficulty == 0 || nano::work_v1::value (current_l.item, work) == output); + debug_assert (current_l.difficulty == 0 || network_constants.work.value (current_l.item, work) == output); // Signal other threads to stop their work next time they check ticket ++ticket; pending.pop_front (); @@ -375,14 +200,12 @@ void nano::work_pool::generate (nano::work_version const version_a, nano::root c boost::optional nano::work_pool::generate (nano::root const & root_a) { - static nano::network_constants network_constants; debug_assert (network_constants.is_dev_network ()); - return generate (nano::work_version::work_1, root_a, network_constants.publish_thresholds.base); + return generate (nano::work_version::work_1, root_a, network_constants.work.base); } boost::optional nano::work_pool::generate (nano::root const & root_a, uint64_t difficulty_a) { - static nano::network_constants network_constants; debug_assert (network_constants.is_dev_network ()); return generate (nano::work_version::work_1, root_a, difficulty_a); } diff --git a/nano/lib/work.hpp b/nano/lib/work.hpp index 6480357d11..15ae1291ab 100644 --- a/nano/lib/work.hpp +++ b/nano/lib/work.hpp @@ -13,36 +13,12 @@ namespace nano { -enum class work_version -{ - unspecified, - work_1 -}; std::string to_string (nano::work_version const version_a); class block; class block_details; enum class block_type : uint8_t; -bool work_validate_entry (nano::block const &); -bool work_validate_entry (nano::work_version const, nano::root const &, uint64_t const); - -uint64_t work_difficulty (nano::work_version const, nano::root const &, uint64_t const); - -uint64_t work_threshold_base (nano::work_version const); -uint64_t work_threshold_entry (nano::work_version const, nano::block_type const); -// Ledger threshold -uint64_t work_threshold (nano::work_version const, nano::block_details const); - -namespace work_v1 -{ - uint64_t value (nano::root const & root_a, uint64_t work_a); - uint64_t threshold_base (); - uint64_t threshold_entry (); - uint64_t threshold (nano::block_details const); -} -double normalized_multiplier (double const, uint64_t const); -double denormalized_multiplier (double const, uint64_t const); class opencl_work; class work_item final { @@ -59,7 +35,7 @@ class work_item final class work_pool final { public: - work_pool (unsigned, std::chrono::nanoseconds = std::chrono::nanoseconds (0), std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> = nullptr); + work_pool (nano::network_constants & network_constants, unsigned, std::chrono::nanoseconds = std::chrono::nanoseconds (0), std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> = nullptr); ~work_pool (); void loop (uint64_t); void stop (); @@ -70,7 +46,7 @@ class work_pool final boost::optional generate (nano::root const &); boost::optional generate (nano::root const &, uint64_t); size_t size (); - nano::network_constants network_constants; + nano::network_constants & network_constants; std::atomic ticket; bool done; std::vector threads; diff --git a/nano/load_test/entry.cpp b/nano/load_test/entry.cpp index e64b096cd4..a3d0e90ce9 100644 --- a/nano/load_test/entry.cpp +++ b/nano/load_test/entry.cpp @@ -43,7 +43,8 @@ constexpr auto ipc_port_start = 62000; void write_config_files (boost::filesystem::path const & data_path, int index) { - nano::daemon_config daemon_config (data_path); + nano::network_params network_params{ nano::network_constants::active_network }; + nano::daemon_config daemon_config{ data_path, network_params }; daemon_config.node.peering_port = peering_port_start + index; daemon_config.node.ipc_config.transport_tcp.enabled = true; daemon_config.node.ipc_config.transport_tcp.port = ipc_port_start + index; @@ -56,7 +57,7 @@ void write_config_files (boost::filesystem::path const & data_path, int index) daemon_config.serialize_toml (toml); toml.write (nano::get_node_toml_config_path (data_path)); - nano::rpc_config rpc_config; + nano::rpc_config rpc_config{ daemon_config.node.network_params.network }; rpc_config.port = rpc_port_start + index; rpc_config.enable_control = true; rpc_config.rpc_process.ipc_port = ipc_port_start + index; @@ -360,8 +361,7 @@ int main (int argc, char * const * argv) data_paths.push_back (std::move (data_path)); } - nano::network_constants network_constants; - auto current_network = network_constants.get_current_network_as_string (); + auto current_network = nano::dev::network_params.network.get_current_network_as_string (); std::vector> nodes; std::vector> rpc_servers; for (auto const & data_path : data_paths) @@ -406,7 +406,7 @@ int main (int argc, char * const * argv) std::string wallet = wallet_create_rpc (ioc, primary_node_results); // Add genesis account to it - wallet_add_rpc (ioc, primary_node_results, wallet, nano::dev_genesis_key.prv.to_string ()); + wallet_add_rpc (ioc, primary_node_results, wallet, nano::dev::genesis_key.prv.to_string ()); // Add destination accounts for (auto & account : destination_accounts) @@ -437,7 +437,7 @@ int main (int argc, char * const * argv) // Send from genesis account to different accounts and receive the funds boost::asio::spawn (ioc, [&ioc, &primary_node_results, &wallet, destination_account, &send_calls_remaining] (boost::asio::yield_context yield) { - send_receive (ioc, wallet, nano::genesis_account.to_account (), destination_account->as_string, send_calls_remaining, primary_node_results, yield); + send_receive (ioc, wallet, nano::dev::genesis->account ().to_account (), destination_account->as_string, send_calls_remaining, primary_node_results, yield); }); } diff --git a/nano/nano_node/daemon.cpp b/nano/nano_node/daemon.cpp index 3e02c10ef5..045158ce68 100644 --- a/nano/nano_node/daemon.cpp +++ b/nano/nano_node/daemon.cpp @@ -1,6 +1,7 @@ #include #include #include +#include #include #include #include @@ -13,10 +14,43 @@ #include +#include #include namespace { +void nano_abort_signal_handler (int signum) +{ + // remove `signum` from signal handling when under Windows +#ifdef _WIN32 + std::signal (signum, SIG_DFL); +#endif + + // create some debugging log files + nano::dump_crash_stacktrace (); + nano::create_load_memory_address_files (); + + // re-raise signal to call the default handler and exit + raise (signum); +} + +void install_abort_signal_handler () +{ + // We catch signal SIGSEGV and SIGABRT not via the signal manager because we want these signal handlers + // to be executed in the stack of the code that caused the signal, so we can dump the stacktrace. +#ifdef _WIN32 + std::signal (SIGSEGV, nano_abort_signal_handler); + std::signal (SIGABRT, nano_abort_signal_handler); +#else + struct sigaction sa = {}; + sa.sa_handler = nano_abort_signal_handler; + sigemptyset (&sa.sa_mask); + sa.sa_flags = SA_RESETHAND; + sigaction (SIGSEGV, &sa, NULL); + sigaction (SIGABRT, &sa, NULL); +#endif +} + volatile sig_atomic_t sig_int_or_term = 0; constexpr std::size_t OPEN_FILE_DESCRIPTORS_LIMIT = 16384; @@ -24,7 +58,7 @@ constexpr std::size_t OPEN_FILE_DESCRIPTORS_LIMIT = 16384; static void load_and_set_bandwidth_params (std::shared_ptr const & node, boost::filesystem::path const & data_path, nano::node_flags const & flags) { - nano::daemon_config config (data_path); + nano::daemon_config config{ data_path, node->network_params }; auto error = nano::read_node_config_toml (data_path, config, flags.config_overrides); if (!error) @@ -39,16 +73,14 @@ static void load_and_set_bandwidth_params (std::shared_ptr const & n void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano::node_flags const & flags) { - // Override segmentation fault and aborting. - nano::signal_manager sigman; - sigman.register_signal_handler (SIGSEGV, sigman.get_debug_files_handler (), false); - sigman.register_signal_handler (SIGABRT, sigman.get_debug_files_handler (), false); + install_abort_signal_handler (); boost::filesystem::create_directories (data_path); boost::system::error_code error_chmod; nano::set_secure_perm_directory (data_path, error_chmod); std::unique_ptr runner; - nano::daemon_config config (data_path); + nano::network_params network_params{ nano::network_constants::active_network }; + nano::daemon_config config{ data_path, network_params }; auto error = nano::read_node_config_toml (data_path, config, flags.config_overrides); nano::set_use_memory_pools (config.node.use_memory_pools); if (!error) @@ -59,12 +91,25 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano:: { config.node.logging.init (data_path); nano::logger_mt logger{ config.node.logging.min_time_between_log_output }; + + auto tls_config (std::make_shared ()); + error = nano::read_tls_config_toml (data_path, *tls_config, logger); + if (error) + { + std::cerr << error.get_message () << std::endl; + std::exit (1); + } + else + { + config.node.websocket_config.tls_config = tls_config; + } + boost::asio::io_context io_ctx; - auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger)); - nano::work_pool opencl_work (config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic & ticket_a) { + auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.work)); + nano::work_pool opencl_work (config.node.network_params.network, config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic & ticket_a) { return opencl->generate_work (version_a, root_a, difficulty_a, ticket_a); } - : std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> (nullptr)); + : std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> (nullptr)); try { // This avoid a blank prompt during any node initialization delays @@ -73,7 +118,15 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano:: logger.always_log (initialization_text); nano::set_file_descriptor_limit (OPEN_FILE_DESCRIPTORS_LIMIT); - logger.always_log (boost::format ("Open file descriptors limit is %1%") % nano::get_file_descriptor_limit ()); + auto const file_descriptor_limit = nano::get_file_descriptor_limit (); + if (file_descriptor_limit < OPEN_FILE_DESCRIPTORS_LIMIT) + { + logger.always_log (boost::format ("WARNING: open file descriptors limit is %1%, lower than the %2% recommended. Node was unable to change it.") % file_descriptor_limit % OPEN_FILE_DESCRIPTORS_LIMIT); + } + else + { + logger.always_log (boost::format ("Open file descriptors limit is %1%") % file_descriptor_limit); + } auto node (std::make_shared (io_ctx, data_path, config.node, opencl_work, flags)); if (!node->init_error ()) @@ -111,13 +164,15 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano:: if (!config.rpc.child_process.enable) { // Launch rpc in-process - nano::rpc_config rpc_config; + nano::rpc_config rpc_config{ config.node.network_params.network }; auto error = nano::read_rpc_config_toml (data_path, rpc_config, flags.rpc_config_overrides); if (error) { std::cout << error.get_message () << std::endl; std::exit (1); } + + rpc_config.tls_config = tls_config; rpc_handler = std::make_unique (*node, ipc_server, config.rpc, [&ipc_server, &workers = node->workers, &io_ctx] () { ipc_server.stop (); workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (3), [&io_ctx] () { @@ -146,6 +201,8 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano:: sig_int_or_term = 1; }; + nano::signal_manager sigman; + // keep trapping Ctrl-C to avoid a second Ctrl-C interrupting tasks started by the first sigman.register_signal_handler (SIGINT, &nano::signal_handler, true); @@ -183,7 +240,7 @@ void nano_daemon::daemon::run (boost::filesystem::path const & data_path, nano:: std::cerr << "Error initializing node\n"; } } - catch (const std::runtime_error & e) + catch (std::runtime_error const & e) { std::cerr << "Error while running node (" << e.what () << ")\n"; } diff --git a/nano/nano_node/entry.cpp b/nano/nano_node/entry.cpp index 341b2a84c3..2a9de2338c 100644 --- a/nano/nano_node/entry.cpp +++ b/nano/nano_node/entry.cpp @@ -74,6 +74,7 @@ int main (int argc, char * const * argv) ("config", boost::program_options::value>()->multitoken(), "Pass node configuration values. This takes precedence over any values in the configuration file. This option can be repeated multiple times.") ("daemon", "Start node daemon") ("compare_rep_weights", "Display a summarized comparison between the hardcoded bootstrap weights and representative weights from the ledger. Full comparison is output to logs") + ("debug_block_dump", "Display all the blocks in the ledger in text format") ("debug_block_count", "Display the number of blocks") ("debug_bootstrap_generate", "Generate bootstrap sequence of blocks") ("debug_dump_frontier_unchecked_dependents", "Dump frontiers which have matching unchecked keys") @@ -139,6 +140,7 @@ int main (int argc, char * const * argv) } } + nano::network_params network_params{ nano::network_constants::active_network }; auto data_path_it = vm.find ("data_path"); boost::filesystem::path data_path ((data_path_it != vm.end ()) ? data_path_it->second.as () : nano::working_path ()); auto ec = nano::handle_node_options (vm); @@ -158,7 +160,7 @@ int main (int argc, char * const * argv) } else if (vm.count ("compare_rep_weights")) { - if (!nano::network_constants ().is_dev_network ()) + if (nano::network_constants::active_network != nano::networks::nano_dev_network) { auto node_flags = nano::inactive_node_flag_defaults (); nano::update_flags (node_flags, vm); @@ -306,6 +308,21 @@ int main (int argc, char * const * argv) result = -1; } } + else if (vm.count ("debug_block_dump")) + { + auto inactive_node = nano::default_inactive_node (data_path, vm); + auto transaction = inactive_node->node->store.tx_begin_read (); + auto i = inactive_node->node->store.block.begin (transaction); + auto end = inactive_node->node->store.block.end (); + for (; i != end; ++i) + { + nano::block_hash hash = i->first; + nano::block_w_sideband sideband = i->second; + std::shared_ptr b = sideband.block; + std::cout << hash.to_string () << std::endl + << b->to_json (); + } + } else if (vm.count ("debug_block_count")) { auto node_flags = nano::inactive_node_flag_defaults (); @@ -324,7 +341,7 @@ int main (int argc, char * const * argv) if (!key.decode_hex (key_it->second.as ())) { nano::keypair genesis (key.to_string ()); - nano::work_pool work (std::numeric_limits::max ()); + nano::work_pool work{ network_params.network, std::numeric_limits::max () }; std::cout << "Genesis: " << genesis.prv.to_string () << "\n" << "Public: " << genesis.pub.to_string () << "\n" << "Account: " << genesis.pub.to_account () << "\n"; @@ -339,9 +356,8 @@ int main (int argc, char * const * argv) << "Public: " << rep.pub.to_string () << "\n" << "Account: " << rep.pub.to_account () << "\n"; } - nano::network_constants network_constants; nano::uint128_t balance (std::numeric_limits::max ()); - nano::open_block genesis_block (reinterpret_cast (genesis.pub), genesis.pub, genesis.pub, genesis.prv, genesis.pub, *work.generate (nano::work_version::work_1, genesis.pub, network_constants.publish_thresholds.epoch_1)); + nano::open_block genesis_block (reinterpret_cast (genesis.pub), genesis.pub, genesis.pub, genesis.prv, genesis.pub, *work.generate (nano::work_version::work_1, genesis.pub, network_params.work.epoch_1)); std::cout << genesis_block.to_json (); std::cout.flush (); nano::block_hash previous (genesis_block.hash ()); @@ -353,7 +369,7 @@ int main (int argc, char * const * argv) { debug_assert (balance > weekly_distribution); balance = balance < (weekly_distribution * 2) ? 0 : balance - weekly_distribution; - nano::send_block send (previous, landing.pub, balance, genesis.prv, genesis.pub, *work.generate (nano::work_version::work_1, previous, network_constants.publish_thresholds.epoch_1)); + nano::send_block send (previous, landing.pub, balance, genesis.prv, genesis.pub, *work.generate (nano::work_version::work_1, previous, network_params.work.epoch_1)); previous = send.hash (); std::cout << send.to_json (); std::cout.flush (); @@ -379,7 +395,7 @@ int main (int argc, char * const * argv) auto current (node->online_reps.trended ()); std::cout << boost::str (boost::format ("Trended Weight %1%\n") % current); auto transaction (node->store.tx_begin_read ()); - for (auto i (node->store.online_weight_begin (transaction)), n (node->store.online_weight_end ()); i != n; ++i) + for (auto i (node->store.online_weight.begin (transaction)), n (node->store.online_weight.end ()); i != n; ++i) { using time_point = std::chrono::system_clock::time_point; time_point ts (std::chrono::duration_cast (std::chrono::nanoseconds (i->first))); @@ -415,13 +431,13 @@ int main (int argc, char * const * argv) // Cache the account heads to make searching quicker against unchecked keys. auto transaction (node->store.tx_begin_read ()); std::unordered_set frontier_hashes; - for (auto i (node->store.accounts_begin (transaction)), n (node->store.accounts_end ()); i != n; ++i) + for (auto i (node->store.account.begin (transaction)), n (node->store.account.end ()); i != n; ++i) { frontier_hashes.insert (i->second.head); } // Check all unchecked keys for matching frontier hashes. Indicates an issue with process_batch algorithm - for (auto i (node->store.unchecked_begin (transaction)), n (node->store.unchecked_end ()); i != n; ++i) + for (auto i (node->store.unchecked.begin (transaction)), n (node->store.unchecked.end ()); i != n; ++i) { auto it = frontier_hashes.find (i->first.key ()); if (it != frontier_hashes.cend ()) @@ -440,14 +456,14 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_profile_kdf")) { - nano::network_params network_params; + auto inactive_node = nano::default_inactive_node (data_path, vm); nano::uint256_union result; nano::uint256_union salt (0); std::string password (""); while (true) { auto begin1 (std::chrono::high_resolution_clock::now ()); - auto success (argon2_hash (1, network_params.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, inactive_node->node->network_params.kdf_work, 1, password.data (), password.size (), salt.bytes.data (), salt.bytes.size (), result.bytes.data (), result.bytes.size (), NULL, 0, Argon2_d, 0x10)); (void)success; auto end1 (std::chrono::high_resolution_clock::now ()); std::cerr << boost::str (boost::format ("Derivation time: %1%us\n") % std::chrono::duration_cast (end1 - begin1).count ()); @@ -455,8 +471,7 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_profile_generate")) { - nano::network_constants network_constants; - uint64_t difficulty{ network_constants.publish_full.base }; + uint64_t difficulty{ nano::work_thresholds::publish_full.base }; auto multiplier_it = vm.find ("multiplier"); if (multiplier_it != vm.end ()) { @@ -491,11 +506,11 @@ int main (int argc, char * const * argv) pow_rate_limiter = std::chrono::nanoseconds (boost::lexical_cast (pow_sleep_interval_it->second.as ())); } - nano::work_pool work (std::numeric_limits::max (), pow_rate_limiter); + nano::work_pool work{ network_params.network, std::numeric_limits::max (), pow_rate_limiter }; nano::change_block block (0, 0, nano::keypair ().prv, 0, 0); if (!result) { - std::cerr << boost::str (boost::format ("Starting generation profiling. Difficulty: %1$#x (%2%x from base difficulty %3$#x)\n") % difficulty % nano::to_string (nano::difficulty::to_multiplier (difficulty, network_constants.publish_full.base), 4) % network_constants.publish_full.base); + std::cerr << boost::str (boost::format ("Starting generation profiling. Difficulty: %1$#x (%2%x from base difficulty %3$#x)\n") % difficulty % nano::to_string (nano::difficulty::to_multiplier (difficulty, nano::work_thresholds::publish_full.base), 4) % nano::work_thresholds::publish_full.base); while (!result) { block.hashables.previous.qwords[0] += 1; @@ -508,7 +523,7 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_profile_validate")) { - uint64_t difficulty{ nano::network_constants ().publish_full.base }; + uint64_t difficulty{ nano::work_thresholds::publish_full.base }; std::cerr << "Starting validation profile" << std::endl; auto start (std::chrono::steady_clock::now ()); bool valid{ false }; @@ -516,7 +531,7 @@ int main (int argc, char * const * argv) uint64_t count{ 10000000U }; // 10M for (uint64_t i (0); i < count; ++i) { - valid = nano::work_v1::value (hash, i) > difficulty; + valid = network_params.work.value (hash, i) > difficulty; } std::ostringstream oss (valid ? "true" : "false"); // IO forces compiler to not dismiss the variable auto total_time (std::chrono::duration_cast (std::chrono::steady_clock::now () - start).count ()); @@ -525,7 +540,6 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_opencl")) { - nano::network_constants network_constants; bool error (false); nano::opencl_environment environment (error); if (!error) @@ -572,7 +586,7 @@ int main (int argc, char * const * argv) return -1; } } - uint64_t difficulty (network_constants.publish_full.base); + uint64_t difficulty (nano::work_thresholds::publish_full.base); auto multiplier_it = vm.find ("multiplier"); if (multiplier_it != vm.end ()) { @@ -609,13 +623,13 @@ int main (int argc, char * const * argv) { nano::logger_mt logger; nano::opencl_config config (platform, device, threads); - auto opencl (nano::opencl_work::create (true, config, logger)); - nano::work_pool work_pool (0, std::chrono::nanoseconds (0), opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic &) { - return opencl->generate_work (version_a, root_a, difficulty_a); - } - : std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> (nullptr)); + auto opencl (nano::opencl_work::create (true, config, logger, network_params.work)); + nano::work_pool work_pool{ network_params.network, 0, std::chrono::nanoseconds (0), opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic &) { + return opencl->generate_work (version_a, root_a, difficulty_a); + } + : std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> (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%. Difficulty: %4$#x (%5%x from base difficulty %6$#x)\n") % platform % device % threads % difficulty % nano::to_string (nano::difficulty::to_multiplier (difficulty, network_constants.publish_full.base), 4) % network_constants.publish_full.base); + std::cerr << boost::str (boost::format ("Starting OpenCL generation profiling. Platform: %1%. Device: %2%. Threads: %3%. Difficulty: %4$#x (%5%x from base difficulty %6$#x)\n") % platform % device % threads % difficulty % nano::to_string (nano::difficulty::to_multiplier (difficulty, nano::work_thresholds::publish_full.base), 4) % nano::work_thresholds::publish_full.base); for (uint64_t i (0); true; ++i) { block.hashables.previous.qwords[0] += 1; @@ -759,7 +773,7 @@ int main (int argc, char * const * argv) } else { - for (const auto & text : results) + for (auto const & text : results) { uint64_from_hex address_hex; if (boost::conversion::try_lexical_convert (text, address_hex)) @@ -887,8 +901,6 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_profile_process")) { - nano::network_constants::set_active_network (nano::nano_networks::nano_dev_network); - nano::network_params dev_params; nano::block_builder builder; size_t num_accounts (100000); size_t num_iterations (5); // 100,000 * 5 * 2 = 1,000,000 blocks @@ -899,7 +911,7 @@ int main (int argc, char * const * argv) nano::inactive_node inactive_node (nano::unique_path (), data_path, node_flags); auto node = inactive_node.node; - nano::block_hash genesis_latest (node->latest (dev_params.ledger.dev_genesis_key.pub)); + nano::block_hash genesis_latest (node->latest (nano::dev::genesis_key.pub)); nano::uint128_t genesis_balance (std::numeric_limits::max ()); // Generating keys std::vector keys (num_accounts); @@ -912,13 +924,13 @@ int main (int argc, char * const * argv) genesis_balance = genesis_balance - 1000000000; auto send = builder.state () - .account (dev_params.ledger.dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (genesis_latest) - .representative (dev_params.ledger.dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (genesis_balance) .link (keys[i].pub) - .sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub) - .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.work.epoch_1)) .build (); genesis_latest = send->hash (); @@ -931,7 +943,7 @@ int main (int argc, char * const * argv) .balance (balances[i]) .link (genesis_latest) .sign (keys[i].prv, keys[i].pub) - .work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.network.publish_thresholds.epoch_1)) + .work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.work.epoch_1)) .build (); frontiers[i] = open->hash (); @@ -952,7 +964,7 @@ int main (int argc, char * const * argv) .balance (balances[j]) .link (keys[other].pub) .sign (keys[j].prv, keys[j].pub) - .work (*node->work.generate (nano::work_version::work_1, frontiers[j], node->network_params.network.publish_thresholds.epoch_1)) + .work (*node->work.generate (nano::work_version::work_1, frontiers[j], node->network_params.work.epoch_1)) .build (); frontiers[j] = send->hash (); @@ -967,7 +979,7 @@ int main (int argc, char * const * argv) .balance (balances[other]) .link (frontiers[j].as_block_hash ()) .sign (keys[other].prv, keys[other].pub) - .work (*node->work.generate (nano::work_version::work_1, frontiers[other], node->network_params.network.publish_thresholds.epoch_1)) + .work (*node->work.generate (nano::work_version::work_1, frontiers[other], node->network_params.work.epoch_1)) .build (); frontiers[other] = receive->hash (); @@ -991,7 +1003,7 @@ int main (int argc, char * const * argv) if (timer_l.after_deadline (std::chrono::seconds (15))) { timer_l.restart (); - std::cout << boost::str (boost::format ("%1% (%2%) blocks processed (unchecked), %3% remaining") % node->ledger.cache.block_count % node->store.unchecked_count (node->store.tx_begin_read ()) % node->block_processor.size ()) << std::endl; + std::cout << boost::str (boost::format ("%1% (%2%) blocks processed (unchecked), %3% remaining") % node->ledger.cache.block_count % node->store.unchecked.count (node->store.tx_begin_read ()) % node->block_processor.size ()) << std::endl; } } @@ -1004,8 +1016,6 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_profile_votes")) { - nano::network_constants::set_active_network (nano::nano_networks::nano_dev_network); - nano::network_params dev_params; nano::block_builder builder; size_t num_elections (40000); size_t num_representatives (25); @@ -1016,7 +1026,7 @@ int main (int argc, char * const * argv) nano::node_wrapper node_wrapper (nano::unique_path (), data_path, node_flags); auto node = node_wrapper.node; - nano::block_hash genesis_latest (node->latest (dev_params.ledger.dev_genesis_key.pub)); + nano::block_hash genesis_latest (node->latest (nano::dev::genesis_key.pub)); nano::uint128_t genesis_balance (std::numeric_limits::max ()); // Generating keys std::vector keys (num_representatives); @@ -1027,13 +1037,13 @@ int main (int argc, char * const * argv) genesis_balance = genesis_balance - balance; auto send = builder.state () - .account (dev_params.ledger.dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (genesis_latest) - .representative (dev_params.ledger.dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (genesis_balance) .link (keys[i].pub) - .sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub) - .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.work.epoch_1)) .build (); genesis_latest = send->hash (); @@ -1046,7 +1056,7 @@ int main (int argc, char * const * argv) .balance (balance) .link (genesis_latest) .sign (keys[i].prv, keys[i].pub) - .work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.network.publish_thresholds.epoch_1)) + .work (*node->work.generate (nano::work_version::work_1, keys[i].pub, node->network_params.work.epoch_1)) .build (); node->ledger.process (transaction, *open); @@ -1059,13 +1069,13 @@ int main (int argc, char * const * argv) nano::keypair destination; auto send = builder.state () - .account (dev_params.ledger.dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (genesis_latest) - .representative (dev_params.ledger.dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (genesis_balance) .link (destination.pub) - .sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub) - .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.network.publish_thresholds.epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node->work.generate (nano::work_version::work_1, genesis_latest, node->network_params.work.epoch_1)) .build (); genesis_latest = send->hash (); @@ -1078,7 +1088,7 @@ int main (int argc, char * const * argv) uint64_t sequence (1); for (auto & i : blocks) { - auto vote (std::make_shared (keys[j].pub, keys[j].prv, sequence, std::vector (1, i->hash ()))); + auto vote (std::make_shared (keys[j].pub, keys[j].prv, sequence, 0, std::vector (1, i->hash ()))); votes.push_back (vote); sequence++; } @@ -1112,8 +1122,6 @@ int main (int argc, char * const * argv) } else if (vm.count ("debug_profile_frontiers_confirmation")) { - nano::force_nano_dev_network (); - nano::network_params dev_params; nano::block_builder builder; size_t count (32 * 1024); auto count_it = vm.find ("count"); @@ -1132,7 +1140,7 @@ int main (int argc, char * const * argv) std::cout << boost::str (boost::format ("Starting generating %1% blocks...\n") % (count * 2)); boost::asio::io_context io_ctx1; boost::asio::io_context io_ctx2; - nano::work_pool work (std::numeric_limits::max ()); + nano::work_pool work{ network_params.network, std::numeric_limits::max () }; nano::logging logging; auto path1 (nano::unique_path ()); auto path2 (nano::unique_path ()); @@ -1143,7 +1151,7 @@ int main (int argc, char * const * argv) { config_overrides = nano::config_overrides (config->second.as> ()); } - nano::daemon_config daemon_config (data_path); + nano::daemon_config daemon_config{ data_path, network_params }; auto error = nano::read_node_config_toml (data_path, daemon_config, config_overrides); nano::node_config config1 = daemon_config.node; @@ -1156,7 +1164,7 @@ int main (int argc, char * const * argv) flags.disable_wallet_bootstrap = true; flags.disable_bootstrap_listener = true; auto node1 (std::make_shared (io_ctx1, path1, config1, work, flags, 0)); - nano::block_hash genesis_latest (node1->latest (dev_params.ledger.dev_genesis_key.pub)); + nano::block_hash genesis_latest (node1->latest (nano::dev::genesis_key.pub)); nano::uint128_t genesis_balance (std::numeric_limits::max ()); // Generating blocks std::deque> blocks; @@ -1166,13 +1174,13 @@ int main (int argc, char * const * argv) genesis_balance = genesis_balance - 1; auto send = builder.state () - .account (dev_params.ledger.dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (genesis_latest) - .representative (dev_params.ledger.dev_genesis_key.pub) + .representative (nano::dev::genesis_key.pub) .balance (genesis_balance) .link (key.pub) - .sign (dev_params.ledger.dev_genesis_key.prv, dev_params.ledger.dev_genesis_key.pub) - .work (*work.generate (nano::work_version::work_1, genesis_latest, dev_params.network.publish_thresholds.epoch_1)) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*work.generate (nano::work_version::work_1, genesis_latest, nano::dev::network_params.work.epoch_1)) .build (); genesis_latest = send->hash (); @@ -1184,7 +1192,7 @@ int main (int argc, char * const * argv) .balance (1) .link (genesis_latest) .sign (key.prv, key.pub) - .work (*work.generate (nano::work_version::work_1, key.pub, dev_params.network.publish_thresholds.epoch_1)) + .work (*work.generate (nano::work_version::work_1, key.pub, nano::dev::network_params.work.epoch_1)) .build (); blocks.push_back (std::move (send)); @@ -1264,7 +1272,7 @@ int main (int argc, char * const * argv) // Insert representative std::cout << "Initializing representative\n"; auto wallet (node1->wallets.create (nano::random_wallet_id ())); - wallet->insert_adhoc (dev_params.ledger.dev_genesis_key.prv); + wallet->insert_adhoc (nano::dev::genesis_key.prv); node2->network.merge_peer (node1->network.endpoint ()); while (node2->rep_crawler.representative_count () == 0) { @@ -1309,7 +1317,7 @@ int main (int argc, char * const * argv) for (;;) { nano::random_pool::generate_block (seed.bytes.data (), seed.bytes.size ()); - std::cout.write (reinterpret_cast (seed.bytes.data ()), seed.bytes.size ()); + std::cout.write (reinterpret_cast (seed.bytes.data ()), seed.bytes.size ()); } } else if (vm.count ("debug_rpc")) @@ -1377,7 +1385,7 @@ int main (int argc, char * const * argv) ++errors; }; - auto start_threads = [node, &threads_count, &threads, &mutex, &condition, &finished] (const auto & function_a, auto & deque_a) { + auto start_threads = [node, &threads_count, &threads, &mutex, &condition, &finished] (auto const & function_a, auto & deque_a) { for (auto i (0U); i < threads_count; ++i) { threads.emplace_back ([&function_a, node, &mutex, &condition, &finished, &deque_a] () { @@ -1409,7 +1417,7 @@ int main (int argc, char * const * argv) std::cout << boost::str (boost::format ("%1% accounts validated\n") % count); } nano::confirmation_height_info confirmation_height_info; - node->store.confirmation_height_get (transaction, account, confirmation_height_info); + node->store.confirmation_height.get (transaction, account, confirmation_height_info); if (confirmation_height_info.height > info.block_count) { @@ -1418,17 +1426,17 @@ int main (int argc, char * const * argv) auto hash (info.open_block); nano::block_hash calculated_hash (0); - auto block (node->store.block_get (transaction, hash)); // Block data + auto block (node->store.block.get (transaction, hash)); // Block data uint64_t height (0); if (node->ledger.pruning && confirmation_height_info.height != 0) { hash = confirmation_height_info.frontier; - block = node->store.block_get (transaction, hash); + block = node->store.block.get (transaction, hash); // Iteration until pruned block bool pruned_block (false); while (!pruned_block && !block->previous ().is_zero ()) { - auto previous_block (node->store.block_get (transaction, block->previous ())); + auto previous_block (node->store.block.get (transaction, block->previous ())); if (previous_block != nullptr) { hash = previous_block->hash (); @@ -1437,7 +1445,7 @@ int main (int argc, char * const * argv) else { pruned_block = true; - if (!node->store.pruned_exists (transaction, block->previous ())) + if (!node->store.pruned.exists (transaction, block->previous ())) { print_error_message (boost::str (boost::format ("Pruned previous block does not exist %1%\n") % block->previous ().to_string ())); } @@ -1451,7 +1459,7 @@ int main (int argc, char * const * argv) } } uint64_t previous_timestamp (0); - nano::account calculated_representative (0); + nano::account calculated_representative{}; while (!hash.is_zero () && block != nullptr) { ++block_count; @@ -1554,7 +1562,7 @@ int main (int argc, char * const * argv) } } } - else if (!node->store.pruned_exists (transaction, block->previous ())) + else if (!node->store.pruned.exists (transaction, block->previous ())) { print_error_message (boost::str (boost::format ("Previous pruned block does not exist %1%\n") % block->previous ().to_string ())); } @@ -1564,15 +1572,15 @@ int main (int argc, char * const * argv) print_error_message (boost::str (boost::format ("Incorrect sideband block details for block %1%\n") % hash.to_string ())); } // Check link epoch version - if (sideband.details.is_receive && (!node->ledger.pruning || !node->store.pruned_exists (transaction, block->link ().as_block_hash ()))) + if (sideband.details.is_receive && (!node->ledger.pruning || !node->store.pruned.exists (transaction, block->link ().as_block_hash ()))) { - if (sideband.source_epoch != node->store.block_version (transaction, block->link ().as_block_hash ())) + if (sideband.source_epoch != node->store.block.version (transaction, block->link ().as_block_hash ())) { print_error_message (boost::str (boost::format ("Incorrect source epoch for block %1%\n") % hash.to_string ())); } } // Check if block work value is correct - if (block->difficulty () < nano::work_threshold (block->work_version (), block->sideband ().details)) + if (node->network_params.work.difficulty (*block) < node->network_params.work.threshold (block->work_version (), block->sideband ().details)) { print_error_message (boost::str (boost::format ("Invalid work for block %1% value: %2%\n") % hash.to_string () % nano::to_string_hex (block->block_work ()))); } @@ -1594,11 +1602,11 @@ int main (int argc, char * const * argv) calculated_representative = block->representative (); } // Retrieving successor block hash - hash = node->store.block_successor (transaction, hash); + hash = node->store.block.successor (transaction, hash); // Retrieving block data if (!hash.is_zero ()) { - block = node->store.block_get (transaction, hash); + block = node->store.block.get (transaction, hash); } } // Check if required block exists @@ -1631,14 +1639,14 @@ int main (int argc, char * const * argv) } size_t const accounts_deque_overflow (32 * 1024); auto transaction (node->store.tx_begin_read ()); - for (auto i (node->store.accounts_begin (transaction)), n (node->store.accounts_end ()); i != n; ++i) + for (auto i (node->store.account.begin (transaction)), n (node->store.account.end ()); i != n; ++i) { { nano::unique_lock lock (mutex); if (accounts.size () > accounts_deque_overflow) { auto wait_ms (250 * accounts.size () / accounts_deque_overflow); - const auto wakeup (std::chrono::steady_clock::now () + std::chrono::milliseconds (wait_ms)); + auto const wakeup (std::chrono::steady_clock::now () + std::chrono::milliseconds (wait_ms)); condition.wait_until (lock, wakeup); } accounts.emplace_back (i->first, i->second); @@ -1661,7 +1669,7 @@ int main (int argc, char * const * argv) } // Validate total block count - auto ledger_block_count (node->store.block_count (transaction)); + auto ledger_block_count (node->store.block.count (transaction)); if (node->flags.enable_pruning) { block_count += 1; // Add disconnected genesis block @@ -1683,11 +1691,11 @@ int main (int argc, char * const * argv) std::cout << boost::str (boost::format ("%1% pending blocks validated\n") % count); } // Check block existance - auto block (node->store.block_get_no_sideband (transaction, key.hash)); + auto block (node->store.block.get_no_sideband (transaction, key.hash)); bool pruned (false); if (block == nullptr) { - pruned = node->ledger.pruning && node->store.pruned_exists (transaction, key.hash); + pruned = node->ledger.pruning && node->store.pruned.exists (transaction, key.hash); if (!pruned) { print_error_message (boost::str (boost::format ("Pending block does not exist %1%\n") % key.hash.to_string ())); @@ -1696,11 +1704,11 @@ int main (int argc, char * const * argv) else { // Check if pending destination is correct - nano::account destination (0); - bool previous_pruned = node->ledger.pruning && node->store.pruned_exists (transaction, block->previous ()); + nano::account destination{}; + bool previous_pruned = node->ledger.pruning && node->store.pruned.exists (transaction, block->previous ()); if (previous_pruned) { - block = node->store.block_get (transaction, key.hash); + block = node->store.block.get (transaction, key.hash); } if (auto state = dynamic_cast (block.get ())) { @@ -1742,14 +1750,14 @@ int main (int argc, char * const * argv) start_threads (check_pending, pending); size_t const pending_deque_overflow (64 * 1024); - for (auto i (node->store.pending_begin (transaction)), n (node->store.pending_end ()); i != n; ++i) + for (auto i (node->store.pending.begin (transaction)), n (node->store.pending.end ()); i != n; ++i) { { nano::unique_lock lock (mutex); if (pending.size () > pending_deque_overflow) { auto wait_ms (50 * pending.size () / pending_deque_overflow); - const auto wakeup (std::chrono::steady_clock::now () + std::chrono::milliseconds (wait_ms)); + auto const wakeup (std::chrono::steady_clock::now () + std::chrono::milliseconds (wait_ms)); condition.wait_until (lock, wakeup); } pending.emplace_back (i->first, i->second); @@ -1786,7 +1794,6 @@ int main (int argc, char * const * argv) node_flags.read_only = false; nano::update_flags (node_flags, vm); nano::inactive_node node (nano::unique_path (), node_flags); - nano::genesis genesis; auto begin (std::chrono::high_resolution_clock::now ()); uint64_t block_count (0); size_t count (0); @@ -1800,7 +1807,7 @@ int main (int argc, char * const * argv) auto transaction (source_node->store.tx_begin_read ()); block_count = source_node->ledger.cache.block_count; std::cout << boost::str (boost::format ("Performing bootstrap emulation, %1% blocks in ledger...") % block_count) << std::endl; - for (auto i (source_node->store.accounts_begin (transaction)), n (source_node->store.accounts_end ()); i != n; ++i) + for (auto i (source_node->store.account.begin (transaction)), n (source_node->store.account.end ()); i != n; ++i) { nano::account const & account (i->first); nano::account_info const & info (i->second); @@ -1808,7 +1815,7 @@ int main (int argc, char * const * argv) while (!hash.is_zero ()) { // Retrieving block data - auto block (source_node->store.block_get_no_sideband (transaction, hash)); + auto block (source_node->store.block.get_no_sideband (transaction, hash)); if (block != nullptr) { ++count; @@ -1845,7 +1852,7 @@ int main (int argc, char * const * argv) if (timer_l.after_deadline (std::chrono::seconds (60))) { timer_l.restart (); - std::cout << boost::str (boost::format ("%1% (%2%) blocks processed (unchecked)") % node.node->ledger.cache.block_count % node.node->store.unchecked_count (node.node->store.tx_begin_read ())) << std::endl; + std::cout << boost::str (boost::format ("%1% (%2%) blocks processed (unchecked)") % node.node->ledger.cache.block_count % node.node->store.unchecked.count (node.node->store.tx_begin_read ())) << std::endl; } } @@ -1865,7 +1872,7 @@ int main (int argc, char * const * argv) auto node = inactive_node->node; auto transaction (node->store.tx_begin_read ()); - for (auto i (node->store.peers_begin (transaction)), n (node->store.peers_end ()); i != n; ++i) + for (auto i (node->store.peer.begin (transaction)), n (node->store.peer.end ()); i != n; ++i) { std::cout << boost::str (boost::format ("%1%\n") % nano::endpoint (boost::asio::ip::address_v6 (i->first.address_bytes ()), i->first.port ())); } @@ -1911,7 +1918,7 @@ int main (int argc, char * const * argv) // Cache the accounts in a collection to make searching quicker against unchecked keys. Group by epoch nano::locked>> opened_account_versions_shared (epoch_count); using opened_account_versions_t = decltype (opened_account_versions_shared)::value_type; - node->store.accounts_for_each_par ( + node->store.account.for_each_par ( [&opened_account_versions_shared, epoch_count] (nano::read_transaction const & /*unused*/, nano::store_iterator i, nano::store_iterator n) { // First cache locally opened_account_versions_t opened_account_versions_l (epoch_count); @@ -1948,7 +1955,7 @@ int main (int argc, char * const * argv) // Iterate all pending blocks and collect the lowest version for each unopened account nano::locked>> unopened_highest_pending_shared; using unopened_highest_pending_t = decltype (unopened_highest_pending_shared)::value_type; - node->store.pending_for_each_par ( + node->store.pending.for_each_par ( [&unopened_highest_pending_shared, &opened_accounts] (nano::read_transaction const & /*unused*/, nano::store_iterator i, nano::store_iterator n) { // First cache locally unopened_highest_pending_t unopened_highest_pending_l; diff --git a/nano/nano_rpc/entry.cpp b/nano/nano_rpc/entry.cpp index 26f342478e..8c8032cd4a 100644 --- a/nano/nano_rpc/entry.cpp +++ b/nano/nano_rpc/entry.cpp @@ -2,6 +2,7 @@ #include #include #include +#include #include #include #include @@ -40,11 +41,26 @@ void run (boost::filesystem::path const & data_path, std::vector co nano::set_secure_perm_directory (data_path, error_chmod); std::unique_ptr runner; - nano::rpc_config rpc_config; + nano::network_params network_params{ nano::network_constants::active_network }; + nano::rpc_config rpc_config{ network_params.network }; auto error = nano::read_rpc_config_toml (data_path, rpc_config, config_overrides); if (!error) { logging_init (data_path); + nano::logger_mt logger; + + auto tls_config (std::make_shared ()); + error = nano::read_tls_config_toml (data_path, *tls_config, logger); + if (error) + { + std::cerr << error.get_message () << std::endl; + std::exit (1); + } + else + { + rpc_config.tls_config = tls_config; + } + boost::asio::io_context io_ctx; nano::signal_manager sigman; try @@ -70,7 +86,7 @@ void run (boost::filesystem::path const & data_path, std::vector co rpc->stop (); } } - catch (const std::runtime_error & e) + catch (std::runtime_error const & e) { std::cerr << "Error while running rpc (" << e.what () << ")\n"; } diff --git a/nano/nano_wallet/entry.cpp b/nano/nano_wallet/entry.cpp index b3d2be54cc..f21272a9e3 100644 --- a/nano/nano_wallet/entry.cpp +++ b/nano/nano_wallet/entry.cpp @@ -4,6 +4,7 @@ #include #include #include +#include #include #include #include @@ -73,13 +74,14 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost boost::filesystem::create_directories (data_path); nano::set_secure_perm_directory (data_path, error_chmod); QPixmap pixmap (":/logo.png"); - QSplashScreen * splash = new QSplashScreen (pixmap); + auto * splash = new QSplashScreen (pixmap); splash->show (); - application.processEvents (); + QApplication::processEvents (); splash->showMessage (QSplashScreen::tr ("Remember - Back Up Your Wallet Seed"), Qt::AlignBottom | Qt::AlignHCenter, Qt::darkGray); - application.processEvents (); + QApplication::processEvents (); - nano::daemon_config config (data_path); + nano::network_params network_params{ nano::network_constants::active_network }; + nano::daemon_config config{ data_path, network_params }; nano::wallet_config wallet_config; auto error = nano::read_node_config_toml (data_path, config, flags.config_overrides); @@ -100,17 +102,30 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost config.node.logging.init (data_path); nano::logger_mt logger{ config.node.logging.min_time_between_log_output }; + auto tls_config (std::make_shared ()); + error = nano::read_tls_config_toml (data_path, *tls_config, logger); + if (error) + { + splash->hide (); + show_error (error.get_message ()); + std::exit (1); + } + else + { + config.node.websocket_config.tls_config = tls_config; + } + boost::asio::io_context io_ctx; nano::thread_runner runner (io_ctx, config.node.io_threads); std::shared_ptr node; std::shared_ptr gui; nano::set_application_icon (application); - auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger)); - nano::work_pool work (config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic &) { - return opencl->generate_work (version_a, root_a, difficulty_a); - } - : std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> (nullptr)); + auto opencl (nano::opencl_work::create (config.opencl_enable, config.opencl, logger, config.node.network_params.work)); + nano::work_pool work{ config.node.network_params.network, config.node.work_threads, config.node.pow_sleep_interval, opencl ? [&opencl] (nano::work_version const version_a, nano::root const & root_a, uint64_t difficulty_a, std::atomic &) { + return opencl->generate_work (version_a, root_a, difficulty_a); + } + : std::function (nano::work_version const, nano::root const &, uint64_t, std::atomic &)> (nullptr) }; node = std::make_shared (io_ctx, data_path, config.node, work, flags); if (!node->init_error ()) { @@ -141,6 +156,7 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost wallet_config.account = wallet->deterministic_insert (transaction); } } + debug_assert (wallet->exists (wallet_config.account)); write_wallet_config (wallet_config, data_path); node->start (); @@ -167,12 +183,15 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost if (!config.rpc.child_process.enable) { // Launch rpc in-process - nano::rpc_config rpc_config; - auto error = nano::read_rpc_config_toml (data_path, rpc_config, flags.rpc_config_overrides); + nano::rpc_config rpc_config{ config.node.network_params.network }; + error = nano::read_rpc_config_toml (data_path, rpc_config, flags.rpc_config_overrides); if (error) { + splash->hide (); show_error (error.get_message ()); + std::exit (1); } + rpc_config.tls_config = tls_config; rpc_handler = std::make_unique (*node, ipc, config.rpc); rpc = nano::get_rpc (io_ctx, rpc_config, *rpc_handler); rpc->start (); @@ -209,13 +228,13 @@ int run_wallet (QApplication & application, int argc, char * const * argv, boost #endif runner.stop_event_processing (); }); - application.postEvent (&processor, new nano_qt::eventloop_event ([&] () { + QApplication::postEvent (&processor, new nano_qt::eventloop_event ([&] () { gui = std::make_shared (application, processor, *node, wallet, wallet_config.account); splash->close (); gui->start (); gui->client_window->show (); })); - result = application.exec (); + result = QApplication::exec (); runner.join (); } else @@ -237,9 +256,11 @@ int main (int argc, char * const * argv) { nano::set_umask (); nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; + + QApplication application (argc, const_cast (argv)); + try { - QApplication application (argc, const_cast (argv)); boost::program_options::options_description description ("Command line options"); // clang-format off description.add_options() @@ -273,9 +294,10 @@ int main (int argc, char * const * argv) } std::vector config_overrides; - if (vm.count ("config")) + const auto configItr = vm.find ("config"); + if (configItr != vm.cend ()) { - config_overrides = vm["config"].as> (); + config_overrides = nano::config_overrides (configItr->second.as> ()); } auto ec = nano::handle_node_options (vm); diff --git a/nano/node/CMakeLists.txt b/nano/node/CMakeLists.txt index dd2d92e12a..6a332b5eec 100644 --- a/nano/node/CMakeLists.txt +++ b/nano/node/CMakeLists.txt @@ -76,6 +76,8 @@ add_library( ipc/ipc_server.cpp json_handler.hpp json_handler.cpp + ledger_walker.hpp + ledger_walker.cpp lmdb/lmdb.hpp lmdb/lmdb.cpp lmdb/lmdb_env.hpp @@ -128,8 +130,6 @@ add_library( state_block_signature_verification.cpp telemetry.hpp telemetry.cpp - testing.hpp - testing.cpp transport/tcp.hpp transport/tcp.cpp transport/transport.hpp @@ -146,10 +146,16 @@ add_library( websocket.cpp websocketconfig.hpp websocketconfig.cpp + websocket_stream.hpp + websocket_stream.cpp write_database_queue.hpp write_database_queue.cpp xorshift.hpp) +if(NOT CMAKE_SYSTEM_NAME STREQUAL "Windows") + set(DISKHASH diskhash) +endif() + target_link_libraries( node rpc @@ -166,6 +172,7 @@ target_link_libraries( Boost::thread Boost::boost rocksdb + ${DISKHASH} ${CMAKE_DL_LIBS} ${psapi_lib}) diff --git a/nano/node/active_transactions.cpp b/nano/node/active_transactions.cpp index 248b659778..38391e4fb1 100644 --- a/nano/node/active_transactions.cpp +++ b/nano/node/active_transactions.cpp @@ -5,7 +5,7 @@ #include #include #include -#include +#include #include #include @@ -14,7 +14,7 @@ using namespace std::chrono; -size_t constexpr nano::active_transactions::max_active_elections_frontier_insertion; +std::size_t constexpr nano::active_transactions::max_active_elections_frontier_insertion; constexpr std::chrono::minutes nano::active_transactions::expired_optimistic_election_info_cutoff; @@ -82,7 +82,7 @@ nano::frontiers_confirmation_info nano::active_transactions::get_frontiers_confi // Limit maximum count of elections to start auto rep_counts (node.wallets.reps ()); bool representative (node.config.enable_voting && rep_counts.voting > 0); - bool half_princpal_representative (representative && rep_counts.half_principal > 0); + bool half_princpal_representative (representative && rep_counts.have_half_rep ()); /* Check less frequently for regular nodes in auto mode */ bool agressive_mode (half_princpal_representative || node.config.frontiers_confirmation == nano::frontiers_confirmation_mode::always); auto is_dev_network = node.network_params.network.is_dev_network (); @@ -132,17 +132,17 @@ void nano::active_transactions::confirm_prioritized_frontiers (nano::transaction { lk.unlock (); nano::account_info info; - auto error = this->node.store.account_get (transaction_a, cementable_account.account, info); + auto error = this->node.store.account.get (transaction_a, cementable_account.account, info); if (!error) { if (!this->confirmation_height_processor.is_processing_block (info.head)) { nano::confirmation_height_info confirmation_height_info; - this->node.store.confirmation_height_get (transaction_a, cementable_account.account, confirmation_height_info); + this->node.store.confirmation_height.get (transaction_a, cementable_account.account, confirmation_height_info); if (info.block_count > confirmation_height_info.height) { - auto block (this->node.store.block_get (transaction_a, info.head)); + auto block (this->node.store.block.get (transaction_a, info.head)); auto previous_balance (this->node.ledger.balance (transaction_a, block->previous ())); auto inserted_election = this->insert_election_from_frontiers_confirmation (block, cementable_account.account, previous_balance, nano::election_behavior::optimistic); if (inserted_election) @@ -180,12 +180,13 @@ void nano::active_transactions::block_cemented_callback (std::shared_ptrhash (), account, amount, is_state_send, pending_account); - node.observers.blocks.notify (nano::election_status{ block_a, 0, 0, std::chrono::duration_cast (std::chrono::system_clock::now ().time_since_epoch ()), std::chrono::duration_values::zero (), 0, 1, 0, nano::election_status_type::inactive_confirmation_height }, {}, account, amount, is_state_send); + bool is_state_epoch (false); + nano::account pending_account{}; + node.process_confirmed_data (transaction, block_a, block_a->hash (), account, amount, is_state_send, is_state_epoch, pending_account); + node.observers.blocks.notify (nano::election_status{ block_a, 0, 0, std::chrono::duration_cast (std::chrono::system_clock::now ().time_since_epoch ()), std::chrono::duration_values::zero (), 0, 1, 0, nano::election_status_type::inactive_confirmation_height }, {}, account, amount, is_state_send, is_state_epoch); } else { @@ -205,18 +206,19 @@ void nano::active_transactions::block_cemented_callback (std::shared_ptrlink ().is_zero () ? block_a->destination () : block_a->link ().as_account ()); node.receive_confirmed (transaction, hash, destination); - nano::account account (0); + nano::account account{}; nano::uint128_t amount (0); bool is_state_send (false); - nano::account pending_account (0); - node.process_confirmed_data (transaction, block_a, hash, account, amount, is_state_send, pending_account); + bool is_state_epoch (false); + nano::account pending_account{}; + node.process_confirmed_data (transaction, block_a, hash, account, amount, is_state_send, is_state_epoch, pending_account); election_lk.lock (); election->status.type = *election_status_type; election->status.confirmation_request_count = election->confirmation_request_count; status_l = election->status; election_lk.unlock (); auto votes (election->votes_with_weight ()); - node.observers.blocks.notify (status_l, votes, account, amount, is_state_send); + node.observers.blocks.notify (status_l, votes, account, amount, is_state_send, is_state_epoch); if (amount > 0) { node.observers.account_balance.notify (account, false); @@ -242,10 +244,7 @@ void nano::active_transactions::block_cemented_callback (std::shared_ptrsize () < nano::active_transactions::max_active_elections_frontier_insertion / 2; }; - - if (cemented_bootstrap_count_reached && was_active && low_active_elections ()) + if (cemented_bootstrap_count_reached && was_active) { // Start or vote for the next unconfirmed block scheduler.activate (account, transaction); @@ -292,18 +291,18 @@ void nano::active_transactions::request_confirm (nano::unique_lock { debug_assert (lock_a.owns_lock ()); - size_t const this_loop_target_l (roots.size ()); + std::size_t const this_loop_target_l (roots.size ()); auto const elections_l{ list_active_impl (this_loop_target_l) }; lock_a.unlock (); nano::confirmation_solicitor solicitor (node.network, node.config); - solicitor.prepare (node.rep_crawler.principal_representatives (std::numeric_limits::max ())); + solicitor.prepare (node.rep_crawler.principal_representatives (std::numeric_limits::max ())); nano::vote_generator_session generator_session (generator); nano::vote_generator_session final_generator_session (generator); auto const election_ttl_cutoff_l (std::chrono::steady_clock::now () - election_time_to_live); - size_t unconfirmed_count_l (0); + std::size_t unconfirmed_count_l (0); nano::timer elapsed (nano::timer_state::started); /* @@ -383,22 +382,22 @@ void nano::active_transactions::cleanup_election (nano::unique_lock node.network.publish_filter.clear (block); } } - node.logger.try_log (boost::str (boost::format ("Election erased for root %1%") % election.qualified_root.to_string ())); + node.logger.try_log (boost::str (boost::format ("Election erased for root %1%, confirmed: %2$b") % election.qualified_root.to_string () % election.confirmed ())); } -std::vector> nano::active_transactions::list_active (size_t max_a) +std::vector> nano::active_transactions::list_active (std::size_t max_a) { nano::lock_guard guard (mutex); return list_active_impl (max_a); } -std::vector> nano::active_transactions::list_active_impl (size_t max_a) const +std::vector> nano::active_transactions::list_active_impl (std::size_t max_a) const { std::vector> result_l; result_l.reserve (std::min (max_a, roots.size ())); { auto & sorted_roots_l (roots.get ()); - size_t count_l{ 0 }; + std::size_t count_l{ 0 }; for (auto i = sorted_roots_l.begin (), n = sorted_roots_l.end (); i != n && count_l < max_a; ++i, ++count_l) { result_l.push_back (i->election); @@ -473,8 +472,8 @@ void nano::active_transactions::frontiers_confirmation (nano::unique_lock timer (nano::timer_state::started); nano::confirmation_height_info confirmation_height_info; @@ -490,9 +489,9 @@ void nano::active_transactions::confirm_expired_frontiers_pessimistically (nano: auto const & account{ i->account }; nano::account_info account_info; bool should_delete{ true }; - if (!node.store.account_get (transaction_a, account, account_info)) + if (!node.store.account.get (transaction_a, account, account_info)) { - node.store.confirmation_height_get (transaction_a, account, confirmation_height_info); + node.store.confirmation_height.get (transaction_a, account, confirmation_height_info); if (account_info.block_count > confirmation_height_info.height) { should_delete = false; @@ -500,12 +499,12 @@ void nano::active_transactions::confirm_expired_frontiers_pessimistically (nano: std::shared_ptr block; if (confirmation_height_info.height == 0) { - block = node.store.block_get (transaction_a, account_info.open_block); + block = node.store.block.get (transaction_a, account_info.open_block); } else { - previous_block = node.store.block_get (transaction_a, confirmation_height_info.frontier); - block = node.store.block_get (transaction_a, previous_block->sideband ().successor); + previous_block = node.store.block.get (transaction_a, confirmation_height_info.frontier); + block = node.store.block.get (transaction_a, previous_block->sideband ().successor); } if (block && !node.confirmation_height_processor.is_processing_block (block->hash ()) && node.ledger.dependents_confirmed (transaction_a, *block)) @@ -580,20 +579,20 @@ void nano::active_transactions::request_loop () } lock.lock (); - const auto stamp_l = std::chrono::steady_clock::now (); + auto const stamp_l = std::chrono::steady_clock::now (); request_confirm (lock); if (!stopped) { - const auto min_sleep_l = std::chrono::milliseconds (node.network_params.network.request_interval_ms / 2); - const auto wakeup_l = std::max (stamp_l + std::chrono::milliseconds (node.network_params.network.request_interval_ms), std::chrono::steady_clock::now () + min_sleep_l); + auto const min_sleep_l = std::chrono::milliseconds (node.network_params.network.request_interval_ms / 2); + auto const wakeup_l = std::max (stamp_l + std::chrono::milliseconds (node.network_params.network.request_interval_ms), std::chrono::steady_clock::now () + min_sleep_l); condition.wait_until (lock, wakeup_l, [&wakeup_l, &stopped = stopped] { return stopped || std::chrono::steady_clock::now () >= wakeup_l; }); } } } -bool nano::active_transactions::prioritize_account_for_confirmation (nano::active_transactions::prioritize_num_uncemented & cementable_frontiers_a, size_t & cementable_frontiers_size_a, nano::account const & account_a, nano::account_info const & info_a, uint64_t confirmation_height_a) +bool nano::active_transactions::prioritize_account_for_confirmation (nano::active_transactions::prioritize_num_uncemented & cementable_frontiers_a, std::size_t & cementable_frontiers_size_a, nano::account const & account_a, nano::account_info const & info_a, uint64_t confirmation_height_a) { auto inserted_new{ false }; if (info_a.block_count > confirmation_height_a && !confirmation_height_processor.is_processing_block (info_a.head)) @@ -642,8 +641,8 @@ void nano::active_transactions::prioritize_frontiers_for_confirmation (nano::tra // Don't try to prioritize when there are a large number of pending confirmation heights as blocks can be cemented in the meantime, making the prioritization less reliable if (confirmation_height_processor.awaiting_processing_size () < confirmed_frontiers_max_pending_size) { - size_t priority_cementable_frontiers_size; - size_t priority_wallet_cementable_frontiers_size; + std::size_t priority_cementable_frontiers_size; + std::size_t priority_wallet_cementable_frontiers_size; { nano::lock_guard guard (mutex); priority_cementable_frontiers_size = priority_cementable_frontiers.size (); @@ -692,10 +691,10 @@ void nano::active_transactions::prioritize_frontiers_for_confirmation (nano::tra for (; i != n && should_iterate (); ++i) { auto const & account (i->first); - if (expired_optimistic_election_infos.get ().count (account) == 0 && !node.store.account_get (transaction_a, account, info)) + if (expired_optimistic_election_infos.get ().count (account) == 0 && !node.store.account.get (transaction_a, account, info)) { nano::confirmation_height_info confirmation_height_info; - node.store.confirmation_height_get (transaction_a, account, confirmation_height_info); + node.store.confirmation_height.get (transaction_a, account, confirmation_height_info); // If it exists in normal priority collection delete from there. auto it = priority_cementable_frontiers.find (account); if (it != priority_cementable_frontiers.end ()) @@ -736,8 +735,8 @@ void nano::active_transactions::prioritize_frontiers_for_confirmation (nano::tra } nano::timer timer (nano::timer_state::started); - auto i (node.store.accounts_begin (transaction_a, next_frontier_account)); - auto n (node.store.accounts_end ()); + auto i (node.store.account.begin (transaction_a, next_frontier_account)); + auto n (node.store.account.end ()); for (; i != n && should_iterate (); ++i) { auto const & account (i->first); @@ -747,7 +746,7 @@ void nano::active_transactions::prioritize_frontiers_for_confirmation (nano::tra if (expired_optimistic_election_infos.get ().count (account) == 0) { nano::confirmation_height_info confirmation_height_info; - node.store.confirmation_height_get (transaction_a, account, confirmation_height_info); + node.store.confirmation_height.get (transaction_a, account, confirmation_height_info); auto insert_newed = prioritize_account_for_confirmation (priority_cementable_frontiers, priority_cementable_frontiers_size, account, info, confirmation_height_info.height); if (insert_newed) { @@ -812,7 +811,7 @@ nano::election_insertion_result nano::active_transactions::insert_impl (nano::un if (!previous_balance_a.is_initialized () && !block_a->previous ().is_zero ()) { auto transaction (node.store.tx_begin_read ()); - if (node.store.block_exists (transaction, block_a->previous ())) + if (node.store.block.exists (transaction, block_a->previous ())) { previous_balance = node.ledger.balance (transaction, block_a->previous ()); } @@ -873,7 +872,7 @@ nano::vote_code nano::active_transactions::vote (std::shared_ptr con } else if (recently_confirmed_by_hash.count (block_hash) == 0) { - add_inactive_votes_cache (lock, block_hash, vote_a->account, vote_a->timestamp); + add_inactive_votes_cache (lock, block_hash, vote_a->account, vote_a->timestamp ()); } else { @@ -890,7 +889,7 @@ nano::vote_code nano::active_transactions::vote (std::shared_ptr con } else if (recently_confirmed_by_hash.count (block->hash ()) == 0) { - add_inactive_votes_cache (lock, block->hash (), vote_a->account, vote_a->timestamp); + add_inactive_votes_cache (lock, block->hash (), vote_a->account, vote_a->timestamp ()); } else { @@ -906,7 +905,7 @@ nano::vote_code nano::active_transactions::vote (std::shared_ptr con bool processed (false); for (auto const & [election, block_hash] : process) { - auto const result_l = election->vote (vote_a->account, vote_a->timestamp, block_hash); + auto const result_l = election->vote (vote_a->account, vote_a->timestamp (), block_hash); processed = processed || result_l.processed; replay = replay || result_l.replay; } @@ -967,34 +966,6 @@ std::shared_ptr nano::active_transactions::winner (nano::block_hash return result; } -void nano::active_transactions::restart (nano::transaction const & transaction_a, std::shared_ptr const & block_a) -{ - auto hash (block_a->hash ()); - auto ledger_block (node.store.block_get (transaction_a, hash)); - if (ledger_block != nullptr && ledger_block->block_work () != block_a->block_work () && !node.block_confirmed_or_being_confirmed (transaction_a, hash)) - { - if (block_a->difficulty () > ledger_block->difficulty ()) - { - // Re-writing the block is necessary to avoid the same work being received later to force restarting the election - // The existing block is re-written, not the arriving block, as that one might not have gone through a full signature check - ledger_block->block_work_set (block_a->block_work ()); - - // Deferred write - node.block_processor.update (ledger_block); - - // Restart election for the upgraded block, previously dropped from elections - if (node.ledger.dependents_confirmed (transaction_a, *ledger_block)) - { - node.stats.inc (nano::stat::type::election, nano::stat::detail::election_restart); - auto previous_balance = node.ledger.balance (transaction_a, ledger_block->previous ()); - auto block_has_account = ledger_block->type () == nano::block_type::state || ledger_block->type () == nano::block_type::open; - auto account = block_has_account ? ledger_block->account () : ledger_block->sideband ().account; - scheduler.activate (account, transaction_a); - } - } - } -} - std::deque nano::active_transactions::list_recently_cemented () { nano::lock_guard lock (mutex); @@ -1066,7 +1037,7 @@ bool nano::active_transactions::empty () return roots.empty (); } -size_t nano::active_transactions::size () +std::size_t nano::active_transactions::size () { nano::lock_guard lock (mutex); return roots.size (); @@ -1135,19 +1106,19 @@ boost::optional nano::active_transactions::confirm_b return status_type; } -size_t nano::active_transactions::priority_cementable_frontiers_size () +std::size_t nano::active_transactions::priority_cementable_frontiers_size () { nano::lock_guard guard (mutex); return priority_cementable_frontiers.size (); } -size_t nano::active_transactions::priority_wallet_cementable_frontiers_size () +std::size_t nano::active_transactions::priority_wallet_cementable_frontiers_size () { nano::lock_guard guard (mutex); return priority_wallet_cementable_frontiers.size (); } -size_t nano::active_transactions::inactive_votes_cache_size () +std::size_t nano::active_transactions::inactive_votes_cache_size () { nano::lock_guard guard (mutex); return inactive_votes_cache.size (); @@ -1281,11 +1252,12 @@ nano::inactive_cache_status nano::active_transactions::inactive_votes_bootstrap_ return inactive_votes_bootstrap_check_impl (lock_a, tally, voters_a.size (), hash_a, previously_a); } -nano::inactive_cache_status nano::active_transactions::inactive_votes_bootstrap_check_impl (nano::unique_lock & lock_a, nano::uint128_t const & tally_a, size_t voters_size_a, nano::block_hash const & hash_a, nano::inactive_cache_status const & previously_a) +nano::inactive_cache_status nano::active_transactions::inactive_votes_bootstrap_check_impl (nano::unique_lock & lock_a, nano::uint128_t const & tally_a, std::size_t voters_size_a, nano::block_hash const & hash_a, nano::inactive_cache_status const & previously_a) { debug_assert (!lock_a.owns_lock ()); nano::inactive_cache_status status (previously_a); - const unsigned election_start_voters_min = node.network_params.network.is_dev_network () ? 2 : node.network_params.network.is_beta_network () ? 5 : 15; + const unsigned election_start_voters_min = node.network_params.network.is_dev_network () ? 2 : node.network_params.network.is_beta_network () ? 5 + : 15; status.tally = tally_a; if (!previously_a.confirmed && tally_a >= node.online_reps.delta ()) { @@ -1304,13 +1276,13 @@ nano::inactive_cache_status nano::active_transactions::inactive_votes_bootstrap_ if ((status.election_started && !previously_a.election_started) || (status.bootstrap_started && !previously_a.bootstrap_started)) { auto transaction (node.store.tx_begin_read ()); - auto block = node.store.block_get (transaction, hash_a); + auto block = node.store.block.get (transaction, hash_a); if (block && status.election_started && !previously_a.election_started && !node.block_confirmed_or_being_confirmed (transaction, hash_a)) { lock_a.lock (); insert_impl (lock_a, block); } - else if (!block && status.bootstrap_started && !previously_a.bootstrap_started && (!node.ledger.pruning || !node.store.pruned_exists (transaction, hash_a))) + else if (!block && status.bootstrap_started && !previously_a.bootstrap_started && (!node.ledger.pruning || !node.store.pruned.exists (transaction, hash_a))) { node.gap_cache.bootstrap_start (hash_a); } @@ -1329,13 +1301,13 @@ bool nano::purge_singleton_inactive_votes_cache_pool_memory () return boost::singleton_pool::purge_memory (); } -size_t nano::active_transactions::election_winner_details_size () +std::size_t nano::active_transactions::election_winner_details_size () { nano::lock_guard guard (election_winner_details_mutex); return election_winner_details.size (); } -nano::cementable_account::cementable_account (nano::account const & account_a, size_t blocks_uncemented_a) : +nano::cementable_account::cementable_account (nano::account const & account_a, std::size_t blocks_uncemented_a) : account (account_a), blocks_uncemented (blocks_uncemented_a) { } @@ -1353,10 +1325,10 @@ bool nano::frontiers_confirmation_info::can_start_elections () const std::unique_ptr nano::collect_container_info (active_transactions & active_transactions, std::string const & name) { - size_t roots_count; - size_t blocks_count; - size_t recently_confirmed_count; - size_t recently_cemented_count; + std::size_t roots_count; + std::size_t blocks_count; + std::size_t recently_confirmed_count; + std::size_t recently_cemented_count; { nano::lock_guard guard (active_transactions.mutex); diff --git a/nano/node/active_transactions.hpp b/nano/node/active_transactions.hpp index 24e8940ac8..1411505bd0 100644 --- a/nano/node/active_transactions.hpp +++ b/nano/node/active_transactions.hpp @@ -39,7 +39,7 @@ class stat; class cementable_account final { public: - cementable_account (nano::account const & account_a, size_t blocks_uncemented_a); + cementable_account (nano::account const & account_a, std::size_t blocks_uncemented_a); nano::account account; uint64_t blocks_uncemented{ 0 }; }; @@ -103,7 +103,7 @@ class frontiers_confirmation_info public: bool can_start_elections () const; - size_t max_elections{ 0 }; + std::size_t max_elections{ 0 }; bool aggressive_mode{ false }; }; @@ -161,15 +161,13 @@ class active_transactions final bool active (nano::qualified_root const &); std::shared_ptr election (nano::qualified_root const &) const; std::shared_ptr winner (nano::block_hash const &) const; - // Returns false if the election was restarted - void restart (nano::transaction const &, std::shared_ptr const &); // Returns a list of elections sorted by difficulty - std::vector> list_active (size_t = std::numeric_limits::max ()); + std::vector> list_active (std::size_t = std::numeric_limits::max ()); void erase (nano::block const &); void erase_hash (nano::block_hash const &); void erase_oldest (); bool empty (); - size_t size (); + std::size_t size (); void stop (); bool publish (std::shared_ptr const &); boost::optional confirm_block (nano::transaction const &, std::shared_ptr const &); @@ -195,10 +193,10 @@ class active_transactions final nano::confirmation_height_processor & confirmation_height_processor; nano::node & node; mutable nano::mutex mutex{ mutex_identifier (mutexes::active) }; - size_t priority_cementable_frontiers_size (); - size_t priority_wallet_cementable_frontiers_size (); - size_t inactive_votes_cache_size (); - size_t election_winner_details_size (); + std::size_t priority_cementable_frontiers_size (); + std::size_t priority_wallet_cementable_frontiers_size (); + std::size_t inactive_votes_cache_size (); + std::size_t election_winner_details_size (); void add_election_winner_details (nano::block_hash const &, std::shared_ptr const &); void remove_election_winner_details (nano::block_hash const &); @@ -235,7 +233,7 @@ class active_transactions final // Erase all blocks from active and, if not confirmed, clear digests from network filters void cleanup_election (nano::unique_lock & lock_a, nano::election const &); // Returns a list of elections sorted by difficulty, mutex must be locked - std::vector> list_active_impl (size_t) const; + std::vector> list_active_impl (std::size_t) const; nano::condition_variable condition; bool started{ false }; @@ -244,7 +242,7 @@ class active_transactions final // Maximum time an election can be kept active if it is extending the container std::chrono::seconds const election_time_to_live; - static size_t constexpr recently_confirmed_size{ 65536 }; + static std::size_t constexpr recently_confirmed_size{ 65536 }; using recent_confirmation = std::pair; // clang-format off boost::multi_index_container &); bool insert_election_from_frontiers_confirmation (std::shared_ptr const &, nano::account const &, nano::uint128_t, nano::election_behavior); - nano::account next_frontier_account{ 0 }; + nano::account next_frontier_account{}; std::chrono::steady_clock::time_point next_frontier_check{ std::chrono::steady_clock::now () }; - constexpr static size_t max_active_elections_frontier_insertion{ 1000 }; + constexpr static std::size_t max_active_elections_frontier_insertion{ 1000 }; prioritize_num_uncemented priority_wallet_cementable_frontiers; prioritize_num_uncemented priority_cementable_frontiers; std::unordered_set wallet_ids_already_iterated; @@ -291,24 +289,24 @@ class active_transactions final bool skip_wallets{ false }; std::atomic optimistic_elections_count{ 0 }; void prioritize_frontiers_for_confirmation (nano::transaction const &, std::chrono::milliseconds, std::chrono::milliseconds); - bool prioritize_account_for_confirmation (prioritize_num_uncemented &, size_t &, nano::account const &, nano::account_info const &, uint64_t); + bool prioritize_account_for_confirmation (prioritize_num_uncemented &, std::size_t &, nano::account const &, nano::account_info const &, uint64_t); unsigned max_optimistic (); void set_next_frontier_check (bool); void add_expired_optimistic_election (nano::election const &); bool should_do_frontiers_confirmation () const; - static size_t constexpr max_priority_cementable_frontiers{ 100000 }; - static size_t constexpr confirmed_frontiers_max_pending_size{ 10000 }; + static std::size_t constexpr max_priority_cementable_frontiers{ 100000 }; + static std::size_t constexpr confirmed_frontiers_max_pending_size{ 10000 }; static std::chrono::minutes constexpr expired_optimistic_election_info_cutoff{ 30 }; ordered_cache inactive_votes_cache; nano::inactive_cache_status inactive_votes_bootstrap_check (nano::unique_lock &, std::vector> const &, nano::block_hash const &, nano::inactive_cache_status const &); nano::inactive_cache_status inactive_votes_bootstrap_check (nano::unique_lock &, nano::account const &, nano::block_hash const &, nano::inactive_cache_status const &); - nano::inactive_cache_status inactive_votes_bootstrap_check_impl (nano::unique_lock &, nano::uint128_t const &, size_t, nano::block_hash const &, nano::inactive_cache_status const &); + nano::inactive_cache_status inactive_votes_bootstrap_check_impl (nano::unique_lock &, nano::uint128_t const &, std::size_t, nano::block_hash const &, nano::inactive_cache_status const &); nano::inactive_cache_information find_inactive_votes_cache_impl (nano::block_hash const &); boost::thread thread; friend class election; friend class election_scheduler; - friend std::unique_ptr collect_container_info (active_transactions &, const std::string &); + friend std::unique_ptr collect_container_info (active_transactions &, std::string const &); friend class active_transactions_vote_replays_Test; friend class frontiers_confirmation_prioritize_frontiers_Test; diff --git a/nano/node/blockprocessor.cpp b/nano/node/blockprocessor.cpp index 84b39b32f6..93756feb3b 100644 --- a/nano/node/blockprocessor.cpp +++ b/nano/node/blockprocessor.cpp @@ -4,7 +4,7 @@ #include #include #include -#include +#include #include @@ -29,7 +29,7 @@ nano::block_processor::block_processor (nano::node & node_a, nano::write_databas next_log (std::chrono::steady_clock::now ()), node (node_a), write_database_queue (write_database_queue_a), - state_block_signature_verification (node.checker, node.ledger.network_params.ledger.epochs, node.config, node.logger, node.flags.block_processor_verification_size) + state_block_signature_verification (node.checker, node.ledger.constants.epochs, node.config, node.logger, node.flags.block_processor_verification_size) { state_block_signature_verification.blocks_verified_callback = [this] (std::deque & items, std::vector const & verifications, std::vector const & hashes, std::vector const & blocks_signatures) { this->process_verified_state_blocks (items, verifications, hashes, blocks_signatures); @@ -81,7 +81,7 @@ void nano::block_processor::flush () flushing = false; } -size_t nano::block_processor::size () +std::size_t nano::block_processor::size () { nano::unique_lock lock (mutex); return (blocks.size () + state_block_signature_verification.size () + forced.size ()); @@ -105,7 +105,7 @@ void nano::block_processor::add (std::shared_ptr const & block_a, u void nano::block_processor::add (nano::unchecked_info const & info_a) { - debug_assert (!nano::work_validate_entry (*info_a.block)); + debug_assert (!node.network_params.work.validate_entry (*info_a.block)); bool quarter_full (size () > node.flags.block_processor_full_size / 4); if (info_a.verified == nano::signature_verification::unknown && (info_a.block->type () == nano::block_type::state || info_a.block->type () == nano::block_type::open || !info_a.account.is_zero ())) { @@ -124,7 +124,7 @@ void nano::block_processor::add (nano::unchecked_info const & info_a) void nano::block_processor::add_local (nano::unchecked_info const & info_a) { release_assert (info_a.verified == nano::signature_verification::unknown && (info_a.block->type () == nano::block_type::state || !info_a.account.is_zero ())); - debug_assert (!nano::work_validate_entry (*info_a.block)); + debug_assert (!node.network_params.work.validate_entry (*info_a.block)); state_block_signature_verification.add (info_a); } @@ -137,15 +137,6 @@ void nano::block_processor::force (std::shared_ptr const & block_a) condition.notify_all (); } -void nano::block_processor::update (std::shared_ptr const & block_a) -{ - { - nano::lock_guard lock (mutex); - updates.push_back (block_a); - } - condition.notify_all (); -} - void nano::block_processor::wait_write () { nano::lock_guard lock (mutex); @@ -188,7 +179,7 @@ bool nano::block_processor::should_log () bool nano::block_processor::have_blocks_ready () { debug_assert (!mutex.try_lock ()); - return !blocks.empty () || !forced.empty () || !updates.empty (); + return !blocks.empty () || !forced.empty (); } bool nano::block_processor::have_blocks () @@ -245,82 +236,67 @@ void nano::block_processor::process_batch (nano::unique_lock & lock lock_a.lock (); timer_l.start (); // Processing blocks - unsigned number_of_blocks_processed (0), number_of_forced_processed (0), number_of_updates_processed (0); + unsigned number_of_blocks_processed (0), number_of_forced_processed (0); auto deadline_reached = [&timer_l, deadline = node.config.block_processor_batch_max_time] { return timer_l.after_deadline (deadline); }; auto processor_batch_reached = [&number_of_blocks_processed, max = node.flags.block_processor_batch_size] { return number_of_blocks_processed >= max; }; auto store_batch_reached = [&number_of_blocks_processed, max = node.store.max_block_write_batch_num ()] { return number_of_blocks_processed >= max; }; while (have_blocks_ready () && (!deadline_reached () || !processor_batch_reached ()) && !awaiting_write && !store_batch_reached ()) { - if ((blocks.size () + state_block_signature_verification.size () + forced.size () + updates.size () > 64) && should_log ()) + if ((blocks.size () + state_block_signature_verification.size () + forced.size () > 64) && should_log ()) { - node.logger.always_log (boost::str (boost::format ("%1% blocks (+ %2% state blocks) (+ %3% forced, %4% updates) in processing queue") % blocks.size () % state_block_signature_verification.size () % forced.size () % updates.size ())); + node.logger.always_log (boost::str (boost::format ("%1% blocks (+ %2% state blocks) (+ %3% forced) in processing queue") % blocks.size () % state_block_signature_verification.size () % forced.size ())); } - if (!updates.empty ()) + nano::unchecked_info info; + nano::block_hash hash (0); + bool force (false); + if (forced.empty ()) { - auto block (updates.front ()); - updates.pop_front (); - lock_a.unlock (); - auto hash (block->hash ()); - if (node.store.block_exists (transaction, hash)) - { - node.store.block_put (transaction, hash, *block); - } - ++number_of_updates_processed; + info = blocks.front (); + blocks.pop_front (); + hash = info.block->hash (); } else { - nano::unchecked_info info; - nano::block_hash hash (0); - bool force (false); - if (forced.empty ()) - { - info = blocks.front (); - blocks.pop_front (); - hash = info.block->hash (); - } - else - { - info = nano::unchecked_info (forced.front (), 0, nano::seconds_since_epoch (), nano::signature_verification::unknown); - forced.pop_front (); - hash = info.block->hash (); - force = true; - number_of_forced_processed++; - } - lock_a.unlock (); - if (force) + info = nano::unchecked_info (forced.front (), 0, nano::seconds_since_epoch (), nano::signature_verification::unknown); + forced.pop_front (); + hash = info.block->hash (); + force = true; + number_of_forced_processed++; + } + lock_a.unlock (); + if (force) + { + auto successor (node.ledger.successor (transaction, info.block->qualified_root ())); + if (successor != nullptr && successor->hash () != hash) { - auto successor (node.ledger.successor (transaction, info.block->qualified_root ())); - if (successor != nullptr && successor->hash () != hash) + // Replace our block with the winner and roll back any dependent blocks + if (node.config.logging.ledger_rollback_logging ()) { - // Replace our block with the winner and roll back any dependent blocks - if (node.config.logging.ledger_rollback_logging ()) - { - node.logger.always_log (boost::str (boost::format ("Rolling back %1% and replacing with %2%") % successor->hash ().to_string () % hash.to_string ())); - } - std::vector> rollback_list; - if (node.ledger.rollback (transaction, successor->hash (), rollback_list)) - { - node.logger.always_log (nano::severity_level::error, boost::str (boost::format ("Failed to roll back %1% because it or a successor was confirmed") % successor->hash ().to_string ())); - } - else if (node.config.logging.ledger_rollback_logging ()) - { - node.logger.always_log (boost::str (boost::format ("%1% blocks rolled back") % rollback_list.size ())); - } - // Deleting from votes cache, stop active transaction - for (auto & i : rollback_list) + node.logger.always_log (boost::str (boost::format ("Rolling back %1% and replacing with %2%") % successor->hash ().to_string () % hash.to_string ())); + } + std::vector> rollback_list; + if (node.ledger.rollback (transaction, successor->hash (), rollback_list)) + { + node.logger.always_log (nano::severity_level::error, boost::str (boost::format ("Failed to roll back %1% because it or a successor was confirmed") % successor->hash ().to_string ())); + } + else if (node.config.logging.ledger_rollback_logging ()) + { + node.logger.always_log (boost::str (boost::format ("%1% blocks rolled back") % rollback_list.size ())); + } + // Deleting from votes cache, stop active transaction + for (auto & i : rollback_list) + { + node.history.erase (i->root ()); + // Stop all rolled back active transactions except initial + if (i->hash () != successor->hash ()) { - node.history.erase (i->root ()); - // Stop all rolled back active transactions except initial - if (i->hash () != successor->hash ()) - { - node.active.erase (*i); - } + node.active.erase (*i); } } } - number_of_blocks_processed++; - process_one (transaction, post_events, info, force); } + number_of_blocks_processed++; + process_one (transaction, post_events, info, force); lock_a.lock (); } awaiting_write = false; @@ -350,6 +326,10 @@ void nano::block_processor::process_live (nano::transaction const & transaction_ { node.network.flood_block_initial (block_a); } + else if (!node.flags.disable_block_processor_republishing) + { + node.network.flood_block (block_a, nano::buffer_drop_policy::limiter); + } if (node.websocket_server && node.websocket_server->any_subscriber (nano::websocket::topic::new_unconfirmed_block)) { @@ -357,7 +337,7 @@ void nano::block_processor::process_live (nano::transaction const & transaction_ } } -nano::process_return nano::block_processor::process_one (nano::write_transaction const & transaction_a, block_post_events & events_a, nano::unchecked_info info_a, const bool forced_a, nano::block_origin const origin_a) +nano::process_return nano::block_processor::process_one (nano::write_transaction const & transaction_a, block_post_events & events_a, nano::unchecked_info info_a, bool const forced_a, nano::block_origin const origin_a) { nano::process_return result; auto block (info_a.block); @@ -367,7 +347,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction { case nano::process_result::progress: { - release_assert (info_a.account.is_zero () || info_a.account == node.store.block_account_calculated (*block)); + release_assert (info_a.account.is_zero () || info_a.account == node.store.block.account_calculated (*block)); if (node.config.logging.ledger_logging ()) { std::string block_string; @@ -403,7 +383,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction } nano::unchecked_key unchecked_key (block->previous (), hash); - node.store.unchecked_put (transaction_a, unchecked_key, info_a); + node.store.unchecked.put (transaction_a, unchecked_key, info_a); events_a.events.emplace_back ([this, hash] (nano::transaction const & /* unused */) { this->node.gap_cache.add (hash); }); @@ -423,7 +403,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction } nano::unchecked_key unchecked_key (node.ledger.block_source (transaction_a, *(block)), hash); - node.store.unchecked_put (transaction_a, unchecked_key, info_a); + node.store.unchecked.put (transaction_a, unchecked_key, info_a); events_a.events.emplace_back ([this, hash] (nano::transaction const & /* unused */) { this->node.gap_cache.add (hash); }); @@ -443,7 +423,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction } nano::unchecked_key unchecked_key (block->account (), hash); // Specific unchecked key starting with epoch open block account public key - node.store.unchecked_put (transaction_a, unchecked_key, info_a); + node.store.unchecked.put (transaction_a, unchecked_key, info_a); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::gap_source); break; @@ -454,7 +434,6 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction { node.logger.try_log (boost::str (boost::format ("Old for: %1%") % hash.to_string ())); } - events_a.events.emplace_back ([this, block = info_a.block, origin_a] (nano::transaction const & post_event_transaction_a) { process_old (post_event_transaction_a, block, origin_a); }); node.stats.inc (nano::stat::type::ledger, nano::stat::detail::old); break; } @@ -526,7 +505,7 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction { if (node.config.logging.ledger_logging ()) { - node.logger.try_log (boost::str (boost::format ("Insufficient work for %1% : %2% (difficulty %3%)") % hash.to_string () % nano::to_string_hex (block->block_work ()) % nano::to_string_hex (block->difficulty ()))); + node.logger.try_log (boost::str (boost::format ("Insufficient work for %1% : %2% (difficulty %3%)") % hash.to_string () % nano::to_string_hex (block->block_work ()) % nano::to_string_hex (node.network_params.work.difficulty (*block)))); } break; } @@ -541,19 +520,14 @@ nano::process_return nano::block_processor::process_one (nano::write_transaction return result; } -void nano::block_processor::process_old (nano::transaction const & transaction_a, std::shared_ptr const & block_a, nano::block_origin const origin_a) -{ - node.active.restart (transaction_a, block_a); -} - void nano::block_processor::queue_unchecked (nano::write_transaction const & transaction_a, nano::hash_or_account const & hash_or_account_a) { - auto unchecked_blocks (node.store.unchecked_get (transaction_a, hash_or_account_a.hash)); + auto unchecked_blocks (node.store.unchecked.get (transaction_a, hash_or_account_a.hash)); for (auto & info : unchecked_blocks) { if (!node.flags.disable_block_processor_unchecked_deletion) { - node.store.unchecked_del (transaction_a, nano::unchecked_key (hash_or_account_a, info.block->hash ())); + node.store.unchecked.del (transaction_a, nano::unchecked_key (hash_or_account_a, info.block->hash ())); } add (info); } @@ -568,8 +542,8 @@ void nano::block_processor::requeue_invalid (nano::block_hash const & hash_a, na std::unique_ptr nano::collect_container_info (block_processor & block_processor, std::string const & name) { - size_t blocks_count; - size_t forced_count; + std::size_t blocks_count; + std::size_t forced_count; { nano::lock_guard guard (block_processor.mutex); diff --git a/nano/node/blockprocessor.hpp b/nano/node/blockprocessor.hpp index decd574271..b3f2ace522 100644 --- a/nano/node/blockprocessor.hpp +++ b/nano/node/blockprocessor.hpp @@ -51,20 +51,19 @@ class block_processor final ~block_processor (); void stop (); void flush (); - size_t size (); + std::size_t size (); bool full (); bool half_full (); void add_local (nano::unchecked_info const & info_a); void add (nano::unchecked_info const &); void add (std::shared_ptr const &, uint64_t = 0); void force (std::shared_ptr const &); - void update (std::shared_ptr const &); void wait_write (); bool should_log (); bool have_blocks_ready (); bool have_blocks (); void process_blocks (); - nano::process_return process_one (nano::write_transaction const &, block_post_events &, nano::unchecked_info, const bool = false, nano::block_origin const = nano::block_origin::remote); + nano::process_return process_one (nano::write_transaction const &, block_post_events &, nano::unchecked_info, bool const = false, nano::block_origin const = nano::block_origin::remote); nano::process_return process_one (nano::write_transaction const &, block_post_events &, std::shared_ptr const &); std::atomic flushing{ false }; // Delay required for average network propagartion before requesting confirmation @@ -74,7 +73,6 @@ class block_processor final void queue_unchecked (nano::write_transaction const &, nano::hash_or_account const &); void process_batch (nano::unique_lock &); void process_live (nano::transaction const &, nano::block_hash const &, std::shared_ptr const &, nano::process_return const &, nano::block_origin const = nano::block_origin::remote); - void process_old (nano::transaction const &, std::shared_ptr const &, nano::block_origin const); void requeue_invalid (nano::block_hash const &, nano::unchecked_info const &); void process_verified_state_blocks (std::deque &, std::vector const &, std::vector const &, std::vector const &); bool stopped{ false }; @@ -83,7 +81,6 @@ class block_processor final std::chrono::steady_clock::time_point next_log; std::deque blocks; std::deque> forced; - std::deque> updates; nano::condition_variable condition; nano::node & node; nano::write_database_queue & write_database_queue; diff --git a/nano/node/bootstrap/bootstrap.cpp b/nano/node/bootstrap/bootstrap.cpp index aa88655636..49a7c0de0e 100644 --- a/nano/node/bootstrap/bootstrap.cpp +++ b/nano/node/bootstrap/bootstrap.cpp @@ -17,7 +17,7 @@ nano::bootstrap_initiator::bootstrap_initiator (nano::node & node_a) : nano::thread_role::set (nano::thread_role::name::bootstrap_connections); connections->run (); })); - for (size_t i = 0; i < node.config.bootstrap_initiator_threads; ++i) + for (std::size_t i = 0; i < node.config.bootstrap_initiator_threads; ++i) { bootstrap_initiator_threads.push_back (boost::thread ([this] () { nano::thread_role::set (nano::thread_role::name::bootstrap_initiator); @@ -55,7 +55,7 @@ void nano::bootstrap_initiator::bootstrap (nano::endpoint const & endpoint_a, bo { if (!node.flags.disable_udp) { - node.network.udp_channels.insert (nano::transport::map_endpoint_to_v6 (endpoint_a), node.network_params.protocol.protocol_version); + node.network.udp_channels.insert (nano::transport::map_endpoint_to_v6 (endpoint_a), node.network_params.network.protocol_version); } else if (!node.flags.disable_tcp_realtime) { @@ -287,8 +287,8 @@ void nano::bootstrap_initiator::notify_listeners (bool in_progress_a) std::unique_ptr nano::collect_container_info (bootstrap_initiator & bootstrap_initiator, std::string const & name) { - size_t count; - size_t cache_count; + std::size_t count; + std::size_t cache_count; { nano::lock_guard guard (bootstrap_initiator.observers_mutex); count = bootstrap_initiator.observers.size (); @@ -387,7 +387,7 @@ std::shared_ptr nano::bootstrap_attempts::find (uint64_ } } -size_t nano::bootstrap_attempts::size () +std::size_t nano::bootstrap_attempts::size () { nano::lock_guard lock (bootstrap_attempts_mutex); return attempts.size (); diff --git a/nano/node/bootstrap/bootstrap.hpp b/nano/node/bootstrap/bootstrap.hpp index 4d70bab086..b88709f88d 100644 --- a/nano/node/bootstrap/bootstrap.hpp +++ b/nano/node/bootstrap/bootstrap.hpp @@ -61,7 +61,7 @@ class pulls_cache final mi::member>>> cache; // clang-format on - constexpr static size_t cache_size_max = 10000; + constexpr static std::size_t cache_size_max = 10000; }; class bootstrap_attempts final { @@ -70,7 +70,7 @@ class bootstrap_attempts final void remove (uint64_t); void clear (); std::shared_ptr find (uint64_t); - size_t size (); + std::size_t size (); std::atomic incremental{ 0 }; nano::mutex bootstrap_attempts_mutex; std::map> attempts; @@ -82,7 +82,7 @@ class bootstrap_initiator final explicit bootstrap_initiator (nano::node &); ~bootstrap_initiator (); void bootstrap (nano::endpoint const &, bool add_to_peers = true, std::string id_a = ""); - void bootstrap (bool force = false, std::string id_a = "", uint32_t const frontiers_age_a = std::numeric_limits::max (), nano::account const & start_account_a = nano::account (0)); + void bootstrap (bool force = false, std::string id_a = "", uint32_t const frontiers_age_a = std::numeric_limits::max (), nano::account const & start_account_a = nano::account{}); bool bootstrap_lazy (nano::hash_or_account const &, bool force = false, bool confirmed = true, std::string id_a = ""); void bootstrap_wallet (std::deque &); void run_bootstrap (); @@ -135,6 +135,6 @@ class bootstrap_limits final static constexpr std::chrono::seconds lazy_flush_delay_sec = std::chrono::seconds (5); static constexpr uint64_t lazy_batch_pull_count_resize_blocks_limit = 4 * 1024 * 1024; static constexpr double lazy_batch_pull_count_resize_ratio = 2.0; - static constexpr size_t lazy_blocks_restart_limit = 1024 * 1024; + static constexpr std::size_t lazy_blocks_restart_limit = 1024 * 1024; }; } diff --git a/nano/node/bootstrap/bootstrap_attempt.cpp b/nano/node/bootstrap/bootstrap_attempt.cpp index eac672c1d3..4380939b06 100644 --- a/nano/node/bootstrap/bootstrap_attempt.cpp +++ b/nano/node/bootstrap/bootstrap_attempt.cpp @@ -23,9 +23,9 @@ nano::bootstrap_attempt::bootstrap_attempt (std::shared_ptr const & { if (id.empty ()) { - nano::random_constants constants; - id = constants.random_128.to_string (); + id = nano::hardened_constants::get ().random_128.to_string (); } + node->logger.always_log (boost::str (boost::format ("Starting %1% bootstrap attempt with ID %2%") % mode_text () % id)); node->bootstrap_initiator.notify_listeners (true); if (node->websocket_server) @@ -194,7 +194,7 @@ void nano::bootstrap_attempt::wallet_start (std::deque &) debug_assert (mode == nano::bootstrap_mode::wallet_lazy); } -size_t nano::bootstrap_attempt::wallet_size () +std::size_t nano::bootstrap_attempt::wallet_size () { debug_assert (mode == nano::bootstrap_mode::wallet_lazy); return 0; diff --git a/nano/node/bootstrap/bootstrap_attempt.hpp b/nano/node/bootstrap/bootstrap_attempt.hpp index 6dc6de8d5b..7c33b68599 100644 --- a/nano/node/bootstrap/bootstrap_attempt.hpp +++ b/nano/node/bootstrap/bootstrap_attempt.hpp @@ -36,7 +36,7 @@ class bootstrap_attempt : public std::enable_shared_from_this virtual bool process_block (std::shared_ptr const &, nano::account const &, uint64_t, nano::bulk_pull::count_t, bool, unsigned); virtual void requeue_pending (nano::account const &); virtual void wallet_start (std::deque &); - virtual size_t wallet_size (); + virtual std::size_t wallet_size (); virtual void get_information (boost::property_tree::ptree &) = 0; nano::mutex next_log_mutex; std::chrono::steady_clock::time_point next_log{ std::chrono::steady_clock::now () }; diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.cpp b/nano/node/bootstrap/bootstrap_bulk_pull.cpp index 3894317782..dee6a7675f 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.cpp @@ -21,7 +21,7 @@ nano::pull_info::pull_info (nano::hash_or_account const & account_or_head_a, nan nano::bulk_pull_client::bulk_pull_client (std::shared_ptr const & connection_a, std::shared_ptr const & attempt_a, nano::pull_info const & pull_a) : connection (connection_a), attempt (attempt_a), - known_account (0), + known_account{}, pull (pull_a), pull_blocks (0), unexpected_count (0) @@ -58,7 +58,7 @@ void nano::bulk_pull_client::request () { debug_assert (!pull.head.is_zero () || pull.retry_limit <= connection->node->network_params.bootstrap.lazy_retry_limit); expected = pull.head; - nano::bulk_pull req; + nano::bulk_pull req{ connection->node->network_params.network }; if (pull.head == pull.head_original && pull.attempts % 4 < 3) { // Account for new pulls @@ -83,7 +83,7 @@ void nano::bulk_pull_client::request () } auto this_l (shared_from_this ()); connection->channel->send ( - req, [this_l] (boost::system::error_code const & ec, size_t size_a) { + req, [this_l] (boost::system::error_code const & ec, std::size_t size_a) { if (!ec) { this_l->throttled_receive_block (); @@ -122,7 +122,7 @@ void nano::bulk_pull_client::throttled_receive_block () void nano::bulk_pull_client::receive_block () { auto this_l (shared_from_this ()); - connection->socket->async_read (connection->receive_buffer, 1, [this_l] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_read (connection->receive_buffer, 1, [this_l] (boost::system::error_code const & ec, std::size_t size_a) { if (!ec) { this_l->received_type (); @@ -149,35 +149,35 @@ void nano::bulk_pull_client::received_type () { case nano::block_type::send: { - socket_l->async_read (connection->receive_buffer, nano::send_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) { + socket_l->async_read (connection->receive_buffer, nano::send_block::size, [this_l, type] (boost::system::error_code const & ec, std::size_t size_a) { this_l->received_block (ec, size_a, type); }); break; } case nano::block_type::receive: { - socket_l->async_read (connection->receive_buffer, nano::receive_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) { + socket_l->async_read (connection->receive_buffer, nano::receive_block::size, [this_l, type] (boost::system::error_code const & ec, std::size_t size_a) { this_l->received_block (ec, size_a, type); }); break; } case nano::block_type::open: { - socket_l->async_read (connection->receive_buffer, nano::open_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) { + socket_l->async_read (connection->receive_buffer, nano::open_block::size, [this_l, type] (boost::system::error_code const & ec, std::size_t size_a) { this_l->received_block (ec, size_a, type); }); break; } case nano::block_type::change: { - socket_l->async_read (connection->receive_buffer, nano::change_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) { + socket_l->async_read (connection->receive_buffer, nano::change_block::size, [this_l, type] (boost::system::error_code const & ec, std::size_t size_a) { this_l->received_block (ec, size_a, type); }); break; } case nano::block_type::state: { - socket_l->async_read (connection->receive_buffer, nano::state_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) { + socket_l->async_read (connection->receive_buffer, nano::state_block::size, [this_l, type] (boost::system::error_code const & ec, std::size_t size_a) { this_l->received_block (ec, size_a, type); }); break; @@ -187,7 +187,7 @@ void nano::bulk_pull_client::received_type () // Avoid re-using slow peers, or peers that sent the wrong blocks. if (!connection->pending_stop && (expected == pull.end || (pull.count != 0 && pull.count == pull_blocks))) { - connection->connections->pool_connection (connection); + connection->connections.pool_connection (connection); } break; } @@ -202,13 +202,13 @@ void nano::bulk_pull_client::received_type () } } -void nano::bulk_pull_client::received_block (boost::system::error_code const & ec, size_t size_a, nano::block_type type_a) +void nano::bulk_pull_client::received_block (boost::system::error_code const & ec, std::size_t size_a, nano::block_type type_a) { if (!ec) { nano::bufferstream stream (connection->receive_buffer->data (), size_a); auto block (nano::deserialize_block (stream, type_a)); - if (block != nullptr && !nano::work_validate_entry (*block)) + if (block != nullptr && !connection->node->network_params.work.validate_entry (*block)) { auto hash (block->hash ()); if (connection->node->config.logging.bulk_pull_logging ()) @@ -253,7 +253,7 @@ void nano::bulk_pull_client::received_block (boost::system::error_code const & e } else if (stop_pull && block_expected) { - connection->connections->pool_connection (connection); + connection->connections.pool_connection (connection); } } else if (block == nullptr) @@ -300,7 +300,7 @@ nano::bulk_pull_account_client::~bulk_pull_account_client () void nano::bulk_pull_account_client::request () { - nano::bulk_pull_account req; + nano::bulk_pull_account req{ connection->node->network_params.network }; req.account = account; req.minimum_amount = connection->node->config.receive_minimum; req.flags = nano::bulk_pull_account_flags::pending_hash_and_amount; @@ -314,7 +314,7 @@ void nano::bulk_pull_account_client::request () } auto this_l (shared_from_this ()); connection->channel->send ( - req, [this_l] (boost::system::error_code const & ec, size_t size_a) { + req, [this_l] (boost::system::error_code const & ec, std::size_t size_a) { if (!ec) { this_l->receive_pending (); @@ -335,8 +335,8 @@ void nano::bulk_pull_account_client::request () void nano::bulk_pull_account_client::receive_pending () { auto this_l (shared_from_this ()); - size_t size_l (sizeof (nano::uint256_union) + sizeof (nano::uint128_union)); - connection->socket->async_read (connection->receive_buffer, size_l, [this_l, size_l] (boost::system::error_code const & ec, size_t size_a) { + std::size_t size_l (sizeof (nano::uint256_union) + sizeof (nano::uint128_union)); + connection->socket->async_read (connection->receive_buffer, size_l, [this_l, size_l] (boost::system::error_code const & ec, std::size_t size_a) { // An issue with asio is that sometimes, instead of reporting a bad file descriptor during disconnect, // we simply get a size of 0. if (size_a == size_l) @@ -376,7 +376,7 @@ void nano::bulk_pull_account_client::receive_pending () } else { - this_l->connection->connections->pool_connection (this_l->connection); + this_l->connection->connections.pool_connection (this_l->connection); } } else @@ -419,7 +419,7 @@ void nano::bulk_pull_server::set_current_end () include_start = false; debug_assert (request != nullptr); auto transaction (connection->node->store.tx_begin_read ()); - if (!connection->node->store.block_exists (transaction, request->end)) + if (!connection->node->store.block.exists (transaction, request->end)) { if (connection->node->config.logging.bulk_pull_logging ()) { @@ -428,7 +428,7 @@ void nano::bulk_pull_server::set_current_end () request->end.clear (); } - if (connection->node->store.block_exists (transaction, request->start.as_block_hash ())) + if (connection->node->store.block.exists (transaction, request->start.as_block_hash ())) { if (connection->node->config.logging.bulk_pull_logging ()) { @@ -441,7 +441,7 @@ void nano::bulk_pull_server::set_current_end () else { nano::account_info info; - auto no_address (connection->node->store.account_get (transaction, request->start.as_account (), info)); + auto no_address (connection->node->store.account.get (transaction, request->start.as_account (), info)); if (no_address) { if (connection->node->config.logging.bulk_pull_logging ()) @@ -494,7 +494,7 @@ void nano::bulk_pull_server::send_next () { connection->node->logger.try_log (boost::str (boost::format ("Sending block: %1%") % block->hash ().to_string ())); } - connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, std::size_t size_a) { this_l->sent_action (ec, size_a); }); } @@ -575,7 +575,7 @@ std::shared_ptr nano::bulk_pull_server::get_next () return result; } -void nano::bulk_pull_server::sent_action (boost::system::error_code const & ec, size_t size_a) +void nano::bulk_pull_server::sent_action (boost::system::error_code const & ec, std::size_t size_a) { if (!ec) { @@ -598,12 +598,12 @@ void nano::bulk_pull_server::send_finished () { connection->node->logger.try_log ("Bulk sending finished"); } - connection->socket->async_write (send_buffer, [this_l] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_write (send_buffer, [this_l] (boost::system::error_code const & ec, std::size_t size_a) { this_l->no_block_sent (ec, size_a); }); } -void nano::bulk_pull_server::no_block_sent (boost::system::error_code const & ec, size_t size_a) +void nano::bulk_pull_server::no_block_sent (boost::system::error_code const & ec, std::size_t size_a) { if (!ec) { @@ -700,7 +700,7 @@ void nano::bulk_pull_account_server::send_frontier () // Send the buffer to the requestor auto this_l (shared_from_this ()); - connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, std::size_t size_a) { this_l->sent_action (ec, size_a); }); } @@ -756,7 +756,7 @@ void nano::bulk_pull_account_server::send_next_block () } auto this_l (shared_from_this ()); - connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, std::size_t size_a) { this_l->sent_action (ec, size_a); }); } @@ -786,7 +786,7 @@ std::pair, std::unique_ptrnode->store.tx_begin_read ()); - auto stream (connection->node->store.pending_begin (stream_transaction, current_key)); + auto stream (connection->node->store.pending.begin (stream_transaction, current_key)); if (stream == nano::store_iterator (nullptr)) { @@ -853,7 +853,7 @@ std::pair, std::unique_ptrnode->logger.try_log ("Bulk sending for an account finished"); } - connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, std::size_t size_a) { this_l->complete (ec, size_a); }); } -void nano::bulk_pull_account_server::complete (boost::system::error_code const & ec, size_t size_a) +void nano::bulk_pull_account_server::complete (boost::system::error_code const & ec, std::size_t size_a) { if (!ec) { diff --git a/nano/node/bootstrap/bootstrap_bulk_pull.hpp b/nano/node/bootstrap/bootstrap_bulk_pull.hpp index f3a39d7978..1b488f4a9b 100644 --- a/nano/node/bootstrap/bootstrap_bulk_pull.hpp +++ b/nano/node/bootstrap/bootstrap_bulk_pull.hpp @@ -34,7 +34,7 @@ class bulk_pull_client final : public std::enable_shared_from_this connection; std::shared_ptr attempt; @@ -66,9 +66,9 @@ class bulk_pull_server final : public std::enable_shared_from_this get_next (); void send_next (); - void sent_action (boost::system::error_code const &, size_t); + void sent_action (boost::system::error_code const &, std::size_t); void send_finished (); - void no_block_sent (boost::system::error_code const &, size_t); + void no_block_sent (boost::system::error_code const &, std::size_t); std::shared_ptr connection; std::unique_ptr request; nano::block_hash current; @@ -85,9 +85,9 @@ class bulk_pull_account_server final : public std::enable_shared_from_this, std::unique_ptr> get_next (); void send_frontier (); void send_next_block (); - void sent_action (boost::system::error_code const &, size_t); + void sent_action (boost::system::error_code const &, std::size_t); void send_finished (); - void complete (boost::system::error_code const &, size_t); + void complete (boost::system::error_code const &, std::size_t); std::shared_ptr connection; std::unique_ptr request; std::unordered_set deduplication; diff --git a/nano/node/bootstrap/bootstrap_bulk_push.cpp b/nano/node/bootstrap/bootstrap_bulk_push.cpp index 1be43031d3..2e15af324d 100644 --- a/nano/node/bootstrap/bootstrap_bulk_push.cpp +++ b/nano/node/bootstrap/bootstrap_bulk_push.cpp @@ -17,10 +17,10 @@ nano::bulk_push_client::~bulk_push_client () void nano::bulk_push_client::start () { - nano::bulk_push message; + nano::bulk_push message{ connection->node->network_params.network }; auto this_l (shared_from_this ()); connection->channel->send ( - message, [this_l] (boost::system::error_code const & ec, size_t size_a) { + message, [this_l] (boost::system::error_code const & ec, std::size_t size_a) { if (!ec) { this_l->push (); @@ -77,7 +77,7 @@ void nano::bulk_push_client::send_finished () { nano::shared_const_buffer buffer (static_cast (nano::block_type::not_a_block)); auto this_l (shared_from_this ()); - connection->channel->send_buffer (buffer, [this_l] (boost::system::error_code const & ec, size_t size_a) { + connection->channel->send_buffer (buffer, [this_l] (boost::system::error_code const & ec, std::size_t size_a) { try { this_l->promise.set_value (false); @@ -96,7 +96,7 @@ void nano::bulk_push_client::push_block (nano::block const & block_a) nano::serialize_block (stream, block_a); } auto this_l (shared_from_this ()); - connection->channel->send_buffer (nano::shared_const_buffer (std::move (buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) { + connection->channel->send_buffer (nano::shared_const_buffer (std::move (buffer)), [this_l] (boost::system::error_code const & ec, std::size_t size_a) { if (!ec) { this_l->push (); @@ -148,7 +148,7 @@ void nano::bulk_push_server::receive () else { auto this_l (shared_from_this ()); - connection->socket->async_read (receive_buffer, 1, [this_l] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_read (receive_buffer, 1, [this_l] (boost::system::error_code const & ec, std::size_t size_a) { if (!ec) { this_l->received_type (); @@ -173,7 +173,7 @@ void nano::bulk_push_server::received_type () case nano::block_type::send: { connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::send, nano::stat::dir::in); - connection->socket->async_read (receive_buffer, nano::send_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_read (receive_buffer, nano::send_block::size, [this_l, type] (boost::system::error_code const & ec, std::size_t size_a) { this_l->received_block (ec, size_a, type); }); break; @@ -181,7 +181,7 @@ void nano::bulk_push_server::received_type () case nano::block_type::receive: { connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::receive, nano::stat::dir::in); - connection->socket->async_read (receive_buffer, nano::receive_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_read (receive_buffer, nano::receive_block::size, [this_l, type] (boost::system::error_code const & ec, std::size_t size_a) { this_l->received_block (ec, size_a, type); }); break; @@ -189,7 +189,7 @@ void nano::bulk_push_server::received_type () case nano::block_type::open: { connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::open, nano::stat::dir::in); - connection->socket->async_read (receive_buffer, nano::open_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_read (receive_buffer, nano::open_block::size, [this_l, type] (boost::system::error_code const & ec, std::size_t size_a) { this_l->received_block (ec, size_a, type); }); break; @@ -197,7 +197,7 @@ void nano::bulk_push_server::received_type () case nano::block_type::change: { connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::change, nano::stat::dir::in); - connection->socket->async_read (receive_buffer, nano::change_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_read (receive_buffer, nano::change_block::size, [this_l, type] (boost::system::error_code const & ec, std::size_t size_a) { this_l->received_block (ec, size_a, type); }); break; @@ -205,7 +205,7 @@ void nano::bulk_push_server::received_type () case nano::block_type::state: { connection->node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::state_block, nano::stat::dir::in); - connection->socket->async_read (receive_buffer, nano::state_block::size, [this_l, type] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_read (receive_buffer, nano::state_block::size, [this_l, type] (boost::system::error_code const & ec, std::size_t size_a) { this_l->received_block (ec, size_a, type); }); break; @@ -226,13 +226,13 @@ void nano::bulk_push_server::received_type () } } -void nano::bulk_push_server::received_block (boost::system::error_code const & ec, size_t size_a, nano::block_type type_a) +void nano::bulk_push_server::received_block (boost::system::error_code const & ec, std::size_t size_a, nano::block_type type_a) { if (!ec) { nano::bufferstream stream (receive_buffer->data (), size_a); auto block (nano::deserialize_block (stream, type_a)); - if (block != nullptr && !nano::work_validate_entry (*block)) + if (block != nullptr && !connection->node->network_params.work.validate_entry (*block)) { connection->node->process_active (std::move (block)); throttled_receive (); diff --git a/nano/node/bootstrap/bootstrap_bulk_push.hpp b/nano/node/bootstrap/bootstrap_bulk_push.hpp index 9ffececaee..f26ac684de 100644 --- a/nano/node/bootstrap/bootstrap_bulk_push.hpp +++ b/nano/node/bootstrap/bootstrap_bulk_push.hpp @@ -30,7 +30,7 @@ class bulk_push_server final : public std::enable_shared_from_this> receive_buffer; std::shared_ptr connection; }; diff --git a/nano/node/bootstrap/bootstrap_connections.cpp b/nano/node/bootstrap/bootstrap_connections.cpp index aa5a8a94f7..cc67f17ec6 100644 --- a/nano/node/bootstrap/bootstrap_connections.cpp +++ b/nano/node/bootstrap/bootstrap_connections.cpp @@ -13,7 +13,7 @@ constexpr double nano::bootstrap_limits::bootstrap_minimum_termination_time_sec; constexpr unsigned nano::bootstrap_limits::bootstrap_max_new_connections; constexpr unsigned nano::bootstrap_limits::requeued_pulls_processed_blocks_factor; -nano::bootstrap_client::bootstrap_client (std::shared_ptr const & node_a, std::shared_ptr const & connections_a, std::shared_ptr const & channel_a, std::shared_ptr const & socket_a) : +nano::bootstrap_client::bootstrap_client (std::shared_ptr const & node_a, nano::bootstrap_connections & connections_a, std::shared_ptr const & channel_a, std::shared_ptr const & socket_a) : node (node_a), connections (connections_a), channel (channel_a), @@ -21,14 +21,14 @@ nano::bootstrap_client::bootstrap_client (std::shared_ptr const & no receive_buffer (std::make_shared> ()), start_time_m (std::chrono::steady_clock::now ()) { - ++connections->connections_count; + ++connections.connections_count; receive_buffer->resize (256); channel->set_endpoint (); } nano::bootstrap_client::~bootstrap_client () { - --connections->connections_count; + --connections.connections_count; } double nano::bootstrap_client::sample_block_rate () @@ -97,7 +97,7 @@ void nano::bootstrap_connections::pool_connection (std::shared_ptrsocket; if (!stopped && !client_a->pending_stop && !node.network.excluded_peers.check (client_a->channel->get_tcp_endpoint ())) { - socket_l->start_timer (node.network_params.node.idle_timeout); + socket_l->start_timer (node.network_params.network.idle_timeout); // Push into idle deque if (!push_front) { @@ -144,7 +144,7 @@ std::shared_ptr nano::bootstrap_connections::find_connec void nano::bootstrap_connections::connect_client (nano::tcp_endpoint const & endpoint_a, bool push_front) { ++connections_count; - auto socket (std::make_shared (node)); + auto socket (std::make_shared (node)); auto this_l (shared_from_this ()); socket->async_connect (endpoint_a, [this_l, socket, endpoint_a, push_front] (boost::system::error_code const & ec) { @@ -154,7 +154,7 @@ void nano::bootstrap_connections::connect_client (nano::tcp_endpoint const & end { this_l->node.logger.try_log (boost::str (boost::format ("Connection established to %1%") % endpoint_a)); } - auto client (std::make_shared (this_l->node.shared (), this_l, std::make_shared (*this_l->node.shared (), socket), socket)); + auto client (std::make_shared (this_l->node.shared (), *this_l, std::make_shared (*this_l->node.shared (), socket), socket)); this_l->pool_connection (client, true, push_front); } else @@ -179,7 +179,7 @@ void nano::bootstrap_connections::connect_client (nano::tcp_endpoint const & end }); } -unsigned nano::bootstrap_connections::target_connections (size_t pulls_remaining, size_t attempts_count) +unsigned nano::bootstrap_connections::target_connections (std::size_t pulls_remaining, std::size_t attempts_count) { auto const attempts_factor = nano::narrow_cast (node.config.bootstrap_connections * attempts_count); if (attempts_factor >= node.config.bootstrap_connections_max) @@ -195,7 +195,7 @@ unsigned nano::bootstrap_connections::target_connections (size_t pulls_remaining struct block_rate_cmp { - bool operator() (const std::shared_ptr & lhs, const std::shared_ptr & rhs) const + bool operator() (std::shared_ptr const & lhs, std::shared_ptr const & rhs) const { return lhs->block_rate > rhs->block_rate; } @@ -204,8 +204,8 @@ struct block_rate_cmp void nano::bootstrap_connections::populate_connections (bool repeat) { double rate_sum = 0.0; - size_t num_pulls = 0; - size_t attempts_count = node.bootstrap_initiator.attempts.size (); + std::size_t num_pulls = 0; + std::size_t attempts_count = node.bootstrap_initiator.attempts.size (); std::priority_queue, std::vector>, block_rate_cmp> sorted_connections; std::unordered_set endpoints; { diff --git a/nano/node/bootstrap/bootstrap_connections.hpp b/nano/node/bootstrap/bootstrap_connections.hpp index dbc63940cb..4dcd193b83 100644 --- a/nano/node/bootstrap/bootstrap_connections.hpp +++ b/nano/node/bootstrap/bootstrap_connections.hpp @@ -21,7 +21,7 @@ class pull_info; class bootstrap_client final : public std::enable_shared_from_this { public: - bootstrap_client (std::shared_ptr const & node_a, std::shared_ptr const & connections_a, std::shared_ptr const & channel_a, std::shared_ptr const & socket_a); + bootstrap_client (std::shared_ptr const & node_a, nano::bootstrap_connections & connections_a, std::shared_ptr const & channel_a, std::shared_ptr const & socket_a); ~bootstrap_client (); std::shared_ptr shared (); void stop (bool force); @@ -29,7 +29,7 @@ class bootstrap_client final : public std::enable_shared_from_this node; - std::shared_ptr connections; + nano::bootstrap_connections & connections; std::shared_ptr channel; std::shared_ptr socket; std::shared_ptr> receive_buffer; @@ -53,7 +53,7 @@ class bootstrap_connections final : public std::enable_shared_from_this find_connection (nano::tcp_endpoint const & endpoint_a); void connect_client (nano::tcp_endpoint const & endpoint_a, bool push_front = false); - unsigned target_connections (size_t pulls_remaining, size_t attempts_count); + unsigned target_connections (std::size_t pulls_remaining, std::size_t attempts_count); void populate_connections (bool repeat = true); void start_populate_connections (); void add_pull (nano::pull_info const & pull_a); diff --git a/nano/node/bootstrap/bootstrap_frontier.cpp b/nano/node/bootstrap/bootstrap_frontier.cpp index a0686bc0a8..42207f0986 100644 --- a/nano/node/bootstrap/bootstrap_frontier.cpp +++ b/nano/node/bootstrap/bootstrap_frontier.cpp @@ -10,11 +10,11 @@ constexpr double nano::bootstrap_limits::bootstrap_minimum_elapsed_seconds_block constexpr double nano::bootstrap_limits::bootstrap_minimum_frontier_blocks_per_sec; constexpr unsigned nano::bootstrap_limits::bulk_push_cost_limit; -constexpr size_t nano::frontier_req_client::size_frontier; +constexpr std::size_t nano::frontier_req_client::size_frontier; void nano::frontier_req_client::run (nano::account const & start_account_a, uint32_t const frontiers_age_a, uint32_t const count_a) { - nano::frontier_req request; + nano::frontier_req request{ connection->node->network_params.network }; request.start = (start_account_a.is_zero () || start_account_a.number () == std::numeric_limits::max ()) ? start_account_a : start_account_a.number () + 1; request.age = frontiers_age_a; request.count = count_a; @@ -24,7 +24,7 @@ void nano::frontier_req_client::run (nano::account const & start_account_a, uint next (); // Load accounts from disk auto this_l (shared_from_this ()); connection->channel->send ( - request, [this_l] (boost::system::error_code const & ec, size_t size_a) { + request, [this_l] (boost::system::error_code const & ec, std::size_t size_a) { if (!ec) { this_l->receive_frontier (); @@ -51,7 +51,7 @@ nano::frontier_req_client::frontier_req_client (std::shared_ptrsocket->async_read (connection->receive_buffer, nano::frontier_req_client::size_frontier, [this_l] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_read (connection->receive_buffer, nano::frontier_req_client::size_frontier, [this_l] (boost::system::error_code const & ec, std::size_t size_a) { // An issue with asio is that sometimes, instead of reporting a bad file descriptor during disconnect, // we simply get a size of 0. if (size_a == nano::frontier_req_client::size_frontier) @@ -89,7 +89,7 @@ void nano::frontier_req_client::unsynced (nano::block_hash const & head, nano::b } } -void nano::frontier_req_client::received_frontier (boost::system::error_code const & ec, size_t size_a) +void nano::frontier_req_client::received_frontier (boost::system::error_code const & ec, std::size_t size_a) { if (!ec) { @@ -199,7 +199,7 @@ void nano::frontier_req_client::received_frontier (boost::system::error_code con catch (std::future_error &) { } - connection->connections->pool_connection (connection); + connection->connections.pool_connection (connection); } } else @@ -216,19 +216,19 @@ void nano::frontier_req_client::next () // Filling accounts deque to prevent often read transactions if (accounts.empty ()) { - size_t max_size (128); + std::size_t max_size (128); auto transaction (connection->node->store.tx_begin_read ()); - for (auto i (connection->node->store.accounts_begin (transaction, current.number () + 1)), n (connection->node->store.accounts_end ()); i != n && accounts.size () != max_size; ++i) + for (auto i (connection->node->store.account.begin (transaction, current.number () + 1)), n (connection->node->store.account.end ()); i != n && accounts.size () != max_size; ++i) { nano::account_info const & info (i->second); nano::account const & account (i->first); accounts.emplace_back (account, info.head); } - /* If loop breaks before max_size, then accounts_end () is reached - Add empty record */ + + /* If loop breaks before max_size, then accounts_end () is reached. Add empty record */ if (accounts.size () != max_size) { - accounts.emplace_back (nano::account (0), nano::block_hash (0)); + accounts.emplace_back (nano::account{}, nano::block_hash (0)); } } // Retrieving accounts from deque @@ -266,7 +266,7 @@ void nano::frontier_req_server::send_next () connection->node->logger.try_log (boost::str (boost::format ("Sending frontier for %1% %2%") % current.to_account () % frontier.to_string ())); } next (); - connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, std::size_t size_a) { this_l->sent_action (ec, size_a); }); } @@ -290,12 +290,12 @@ void nano::frontier_req_server::send_finished () { connection->node->logger.try_log ("Frontier sending finished"); } - connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_write (nano::shared_const_buffer (std::move (send_buffer)), [this_l] (boost::system::error_code const & ec, std::size_t size_a) { this_l->no_block_sent (ec, size_a); }); } -void nano::frontier_req_server::no_block_sent (boost::system::error_code const & ec, size_t size_a) +void nano::frontier_req_server::no_block_sent (boost::system::error_code const & ec, std::size_t size_a) { if (!ec) { @@ -310,7 +310,7 @@ void nano::frontier_req_server::no_block_sent (boost::system::error_code const & } } -void nano::frontier_req_server::sent_action (boost::system::error_code const & ec, size_t size_a) +void nano::frontier_req_server::sent_action (boost::system::error_code const & ec, std::size_t size_a) { if (!ec) { @@ -333,11 +333,11 @@ void nano::frontier_req_server::next () { auto now (nano::seconds_since_epoch ()); bool disable_age_filter (request->age == std::numeric_limitsage)>::max ()); - size_t max_size (128); + std::size_t max_size (128); auto transaction (connection->node->store.tx_begin_read ()); if (!send_confirmed ()) { - for (auto i (connection->node->store.accounts_begin (transaction, current.number () + 1)), n (connection->node->store.accounts_end ()); i != n && accounts.size () != max_size; ++i) + for (auto i (connection->node->store.account.begin (transaction, current.number () + 1)), n (connection->node->store.account.end ()); i != n && accounts.size () != max_size; ++i) { nano::account_info const & info (i->second); if (disable_age_filter || (now - info.modified) <= request->age) @@ -349,7 +349,7 @@ void nano::frontier_req_server::next () } else { - for (auto i (connection->node->store.confirmation_height_begin (transaction, current.number () + 1)), n (connection->node->store.confirmation_height_end ()); i != n && accounts.size () != max_size; ++i) + for (auto i (connection->node->store.confirmation_height.begin (transaction, current.number () + 1)), n (connection->node->store.confirmation_height.end ()); i != n && accounts.size () != max_size; ++i) { nano::confirmation_height_info const & info (i->second); nano::block_hash const & confirmed_frontier (info.frontier); @@ -360,11 +360,11 @@ void nano::frontier_req_server::next () } } } - /* If loop breaks before max_size, then accounts_end () is reached - Add empty record to finish frontier_req_server */ + + /* If loop breaks before max_size, then accounts_end () is reached. Add empty record to finish frontier_req_server */ if (accounts.size () != max_size) { - accounts.emplace_back (nano::account (0), nano::block_hash (0)); + accounts.emplace_back (nano::account{}, nano::block_hash (0)); } } // Retrieving accounts from deque diff --git a/nano/node/bootstrap/bootstrap_frontier.hpp b/nano/node/bootstrap/bootstrap_frontier.hpp index 5ad433e25c..2357abb7e1 100644 --- a/nano/node/bootstrap/bootstrap_frontier.hpp +++ b/nano/node/bootstrap/bootstrap_frontier.hpp @@ -15,7 +15,7 @@ class frontier_req_client final : public std::enable_shared_from_this const &, std::shared_ptr const &); void run (nano::account const & start_account_a, uint32_t const frontiers_age_a, uint32_t const count_a); void receive_frontier (); - void received_frontier (boost::system::error_code const &, size_t); + void received_frontier (boost::system::error_code const &, std::size_t); bool bulk_push_available (); void unsynced (nano::block_hash const &, nano::block_hash const &); void next (); @@ -32,7 +32,7 @@ class frontier_req_client final : public std::enable_shared_from_this> accounts; uint32_t frontiers_age{ std::numeric_limits::max () }; uint32_t count_limit{ std::numeric_limits::max () }; - static size_t constexpr size_frontier = sizeof (nano::account) + sizeof (nano::block_hash); + static std::size_t constexpr size_frontier = sizeof (nano::account) + sizeof (nano::block_hash); }; class bootstrap_server; class frontier_req; @@ -41,16 +41,16 @@ class frontier_req_server final : public std::enable_shared_from_this const &, std::unique_ptr); void send_next (); - void sent_action (boost::system::error_code const &, size_t); + void sent_action (boost::system::error_code const &, std::size_t); void send_finished (); - void no_block_sent (boost::system::error_code const &, size_t); + void no_block_sent (boost::system::error_code const &, std::size_t); void next (); bool send_confirmed (); std::shared_ptr connection; nano::account current; nano::block_hash frontier; std::unique_ptr request; - size_t count; + std::size_t count; std::deque> accounts; }; } diff --git a/nano/node/bootstrap/bootstrap_lazy.cpp b/nano/node/bootstrap/bootstrap_lazy.cpp index 372d663186..aab57e6623 100644 --- a/nano/node/bootstrap/bootstrap_lazy.cpp +++ b/nano/node/bootstrap/bootstrap_lazy.cpp @@ -11,7 +11,7 @@ constexpr std::chrono::seconds nano::bootstrap_limits::lazy_flush_delay_sec; constexpr uint64_t nano::bootstrap_limits::lazy_batch_pull_count_resize_blocks_limit; constexpr double nano::bootstrap_limits::lazy_batch_pull_count_resize_ratio; -constexpr size_t nano::bootstrap_limits::lazy_blocks_restart_limit; +constexpr std::size_t nano::bootstrap_limits::lazy_blocks_restart_limit; nano::bootstrap_attempt_lazy::bootstrap_attempt_lazy (std::shared_ptr const & node_a, uint64_t incremental_id_a, std::string const & id_a) : nano::bootstrap_attempt (node_a, nano::bootstrap_mode::lazy, incremental_id_a, id_a) @@ -30,7 +30,7 @@ bool nano::bootstrap_attempt_lazy::lazy_start (nano::hash_or_account const & has nano::unique_lock lock (mutex); bool inserted (false); // Add start blocks, limit 1024 (4k with disabled legacy bootstrap) - size_t max_keys (node->flags.disable_legacy_bootstrap ? 4 * 1024 : 1024); + std::size_t max_keys (node->flags.disable_legacy_bootstrap ? 4 * 1024 : 1024); if (lazy_keys.size () < max_keys && lazy_keys.find (hash_or_account_a.as_block_hash ()) == lazy_keys.end () && !lazy_blocks_processed (hash_or_account_a.as_block_hash ())) { lazy_keys.insert (hash_or_account_a.as_block_hash ()); @@ -92,13 +92,13 @@ uint32_t nano::bootstrap_attempt_lazy::lazy_batch_size () void nano::bootstrap_attempt_lazy::lazy_pull_flush (nano::unique_lock & lock_a) { - static size_t const max_pulls (static_cast (nano::bootstrap_limits::bootstrap_connection_scale_target_blocks) * 3); + static std::size_t const max_pulls (static_cast (nano::bootstrap_limits::bootstrap_connection_scale_target_blocks) * 3); if (pulling < max_pulls) { debug_assert (node->network_params.bootstrap.lazy_max_pull_blocks <= std::numeric_limits::max ()); nano::pull_info::count_t batch_count (lazy_batch_size ()); uint64_t read_count (0); - size_t count (0); + std::size_t count (0); auto transaction (node->store.tx_begin_read ()); while (!lazy_pulls.empty () && count < max_pulls) { @@ -247,7 +247,7 @@ bool nano::bootstrap_attempt_lazy::process_block_lazy (std::shared_ptrsource ().is_zero () && !node->ledger.block_or_pruned_exists (block_a->source ()) && block_a->source () != node->network_params.ledger.genesis_account) + if (!block_a->source ().is_zero () && !node->ledger.block_or_pruned_exists (block_a->source ()) && block_a->source () != node->network_params.ledger.genesis->account ()) { lazy_add (block_a->source (), retry_limit); } @@ -413,7 +413,7 @@ void nano::bootstrap_attempt_lazy::lazy_blocks_erase (nano::block_hash const & h if (erased) { --lazy_blocks_count; - debug_assert (lazy_blocks_count != std::numeric_limits::max ()); + debug_assert (lazy_blocks_count != std::numeric_limits::max ()); } } @@ -555,7 +555,7 @@ void nano::bootstrap_attempt_wallet::run () condition.notify_all (); } -size_t nano::bootstrap_attempt_wallet::wallet_size () +std::size_t nano::bootstrap_attempt_wallet::wallet_size () { nano::lock_guard lock (mutex); return wallet_accounts.size (); diff --git a/nano/node/bootstrap/bootstrap_lazy.hpp b/nano/node/bootstrap/bootstrap_lazy.hpp index b300b912e4..f456884ec3 100644 --- a/nano/node/bootstrap/bootstrap_lazy.hpp +++ b/nano/node/bootstrap/bootstrap_lazy.hpp @@ -48,15 +48,15 @@ class bootstrap_attempt_lazy final : public bootstrap_attempt bool lazy_processed_or_exists (nano::block_hash const &) override; unsigned lazy_retry_limit_confirmed (); void get_information (boost::property_tree::ptree &) override; - std::unordered_set lazy_blocks; + std::unordered_set lazy_blocks; std::unordered_map lazy_state_backlog; std::unordered_set lazy_undefined_links; std::unordered_map lazy_balances; std::unordered_set lazy_keys; std::deque> lazy_pulls; std::chrono::steady_clock::time_point lazy_start_time; - std::atomic lazy_blocks_count{ 0 }; - size_t peer_count{ 0 }; + std::atomic lazy_blocks_count{ 0 }; + std::size_t peer_count{ 0 }; /** The maximum number of records to be read in while iterating over long lazy containers */ static uint64_t constexpr batch_read_size = 256; }; @@ -70,7 +70,7 @@ class bootstrap_attempt_wallet final : public bootstrap_attempt void run () override; void wallet_start (std::deque &) override; bool wallet_finished (); - size_t wallet_size () override; + std::size_t wallet_size () override; void get_information (boost::property_tree::ptree &) override; std::deque wallet_accounts; }; diff --git a/nano/node/bootstrap/bootstrap_legacy.hpp b/nano/node/bootstrap/bootstrap_legacy.hpp index 0abe0f901c..7387556e43 100644 --- a/nano/node/bootstrap/bootstrap_legacy.hpp +++ b/nano/node/bootstrap/bootstrap_legacy.hpp @@ -33,7 +33,7 @@ class bootstrap_attempt_legacy : public bootstrap_attempt std::weak_ptr push; std::deque frontier_pulls; std::vector> bulk_push_targets; - nano::account start_account{ 0 }; + nano::account start_account{}; std::atomic account_count{ 0 }; uint32_t frontiers_age; }; diff --git a/nano/node/bootstrap/bootstrap_server.cpp b/nano/node/bootstrap/bootstrap_server.cpp index e6207b7400..51db5fc6b0 100644 --- a/nano/node/bootstrap/bootstrap_server.cpp +++ b/nano/node/bootstrap/bootstrap_server.cpp @@ -51,7 +51,7 @@ void nano::bootstrap_listener::stop () } } -size_t nano::bootstrap_listener::connection_count () +std::size_t nano::bootstrap_listener::connection_count () { nano::lock_guard lock (mutex); return connections.size (); @@ -102,6 +102,7 @@ nano::bootstrap_server::bootstrap_server (std::shared_ptr const & socket (socket_a), node (node_a) { + debug_assert (socket_a != nullptr); receive_buffer->resize (1024); } @@ -111,11 +112,11 @@ nano::bootstrap_server::~bootstrap_server () { node->logger.try_log ("Exiting incoming TCP/bootstrap server"); } - if (type == nano::bootstrap_server_type::bootstrap) + if (socket->type () == nano::socket::type_t::bootstrap) { --node->bootstrap.bootstrap_count; } - else if (type == nano::bootstrap_server_type::realtime) + else if (socket->type () == nano::socket::type_t::realtime) { --node->bootstrap.realtime_count; // Clear temporary channel @@ -135,32 +136,29 @@ void nano::bootstrap_server::stop () { if (!stopped.exchange (true)) { - if (socket != nullptr) - { - socket->close (); - } + socket->close (); } } void nano::bootstrap_server::receive () { // Increase timeout to receive TCP header (idle server socket) - socket->set_timeout (node->network_params.node.idle_timeout); + socket->timeout_set (node->network_params.network.idle_timeout); auto this_l (shared_from_this ()); - socket->async_read (receive_buffer, 8, [this_l] (boost::system::error_code const & ec, size_t size_a) { + socket->async_read (receive_buffer, 8, [this_l] (boost::system::error_code const & ec, std::size_t size_a) { // Set remote_endpoint if (this_l->remote_endpoint.port () == 0) { this_l->remote_endpoint = this_l->socket->remote_endpoint (); } // Decrease timeout to default - this_l->socket->set_timeout (this_l->node->config.tcp_io_timeout); + this_l->socket->timeout_set (this_l->node->config.tcp_io_timeout); // Receive header this_l->receive_header_action (ec, size_a); }); } -void nano::bootstrap_server::receive_header_action (boost::system::error_code const & ec, size_t size_a) +void nano::bootstrap_server::receive_header_action (boost::system::error_code const & ec, std::size_t size_a) { if (!ec) { @@ -176,7 +174,7 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co case nano::message_type::bulk_pull: { node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull, nano::stat::dir::in); - socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) { + socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, std::size_t size_a) { this_l->receive_bulk_pull_action (ec, size_a, header); }); break; @@ -184,7 +182,7 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co case nano::message_type::bulk_pull_account: { node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::bulk_pull_account, nano::stat::dir::in); - socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) { + socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, std::size_t size_a) { this_l->receive_bulk_pull_account_action (ec, size_a, header); }); break; @@ -192,7 +190,7 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co case nano::message_type::frontier_req: { node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::frontier_req, nano::stat::dir::in); - socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) { + socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, std::size_t size_a) { this_l->receive_frontier_req_action (ec, size_a, header); }); break; @@ -208,35 +206,35 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co } case nano::message_type::keepalive: { - socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) { + socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, std::size_t size_a) { this_l->receive_keepalive_action (ec, size_a, header); }); break; } case nano::message_type::publish: { - socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) { + socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, std::size_t size_a) { this_l->receive_publish_action (ec, size_a, header); }); break; } case nano::message_type::confirm_ack: { - socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) { + socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, std::size_t size_a) { this_l->receive_confirm_ack_action (ec, size_a, header); }); break; } case nano::message_type::confirm_req: { - socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) { + socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, std::size_t size_a) { this_l->receive_confirm_req_action (ec, size_a, header); }); break; } case nano::message_type::node_id_handshake: { - socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) { + socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, std::size_t size_a) { this_l->receive_node_id_handshake_action (ec, size_a, header); }); break; @@ -246,9 +244,8 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co if (is_realtime_connection ()) { // Only handle telemetry requests if they are outside of the cutoff time - auto is_very_first_message = last_telemetry_req == std::chrono::steady_clock::time_point{}; auto cache_exceeded = std::chrono::steady_clock::now () >= last_telemetry_req + nano::telemetry_cache_cutoffs::network_to_time (node->network_params.network); - if (is_very_first_message || cache_exceeded) + if (cache_exceeded) { last_telemetry_req = std::chrono::steady_clock::now (); add_request (std::make_unique (header)); @@ -263,7 +260,7 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co } case nano::message_type::telemetry_ack: { - socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, size_t size_a) { + socket->async_read (receive_buffer, header.payload_length_bytes (), [this_l, header] (boost::system::error_code const & ec, std::size_t size_a) { this_l->receive_telemetry_ack_action (ec, size_a, header); }); break; @@ -288,7 +285,7 @@ void nano::bootstrap_server::receive_header_action (boost::system::error_code co } } -void nano::bootstrap_server::receive_bulk_pull_action (boost::system::error_code const & ec, size_t size_a, nano::message_header const & header_a) +void nano::bootstrap_server::receive_bulk_pull_action (boost::system::error_code const & ec, std::size_t size_a, nano::message_header const & header_a) { if (!ec) { @@ -310,7 +307,7 @@ void nano::bootstrap_server::receive_bulk_pull_action (boost::system::error_code } } -void nano::bootstrap_server::receive_bulk_pull_account_action (boost::system::error_code const & ec, size_t size_a, nano::message_header const & header_a) +void nano::bootstrap_server::receive_bulk_pull_account_action (boost::system::error_code const & ec, std::size_t size_a, nano::message_header const & header_a) { if (!ec) { @@ -333,7 +330,7 @@ void nano::bootstrap_server::receive_bulk_pull_account_action (boost::system::er } } -void nano::bootstrap_server::receive_frontier_req_action (boost::system::error_code const & ec, size_t size_a, nano::message_header const & header_a) +void nano::bootstrap_server::receive_frontier_req_action (boost::system::error_code const & ec, std::size_t size_a, nano::message_header const & header_a) { if (!ec) { @@ -362,7 +359,7 @@ void nano::bootstrap_server::receive_frontier_req_action (boost::system::error_c } } -void nano::bootstrap_server::receive_keepalive_action (boost::system::error_code const & ec, size_t size_a, nano::message_header const & header_a) +void nano::bootstrap_server::receive_keepalive_action (boost::system::error_code const & ec, std::size_t size_a, nano::message_header const & header_a) { if (!ec) { @@ -387,7 +384,7 @@ void nano::bootstrap_server::receive_keepalive_action (boost::system::error_code } } -void nano::bootstrap_server::receive_telemetry_ack_action (boost::system::error_code const & ec, size_t size_a, nano::message_header const & header_a) +void nano::bootstrap_server::receive_telemetry_ack_action (boost::system::error_code const & ec, std::size_t size_a, nano::message_header const & header_a) { if (!ec) { @@ -412,7 +409,7 @@ void nano::bootstrap_server::receive_telemetry_ack_action (boost::system::error_ } } -void nano::bootstrap_server::receive_publish_action (boost::system::error_code const & ec, size_t size_a, nano::message_header const & header_a) +void nano::bootstrap_server::receive_publish_action (boost::system::error_code const & ec, std::size_t size_a, nano::message_header const & header_a) { if (!ec) { @@ -426,7 +423,7 @@ void nano::bootstrap_server::receive_publish_action (boost::system::error_code c { if (is_realtime_connection ()) { - if (!nano::work_validate_entry (*request->block)) + if (!node->network_params.work.validate_entry (*request->block)) { add_request (std::unique_ptr (request.release ())); } @@ -453,7 +450,7 @@ void nano::bootstrap_server::receive_publish_action (boost::system::error_code c } } -void nano::bootstrap_server::receive_confirm_req_action (boost::system::error_code const & ec, size_t size_a, nano::message_header const & header_a) +void nano::bootstrap_server::receive_confirm_req_action (boost::system::error_code const & ec, std::size_t size_a, nano::message_header const & header_a) { if (!ec) { @@ -475,7 +472,7 @@ void nano::bootstrap_server::receive_confirm_req_action (boost::system::error_co } } -void nano::bootstrap_server::receive_confirm_ack_action (boost::system::error_code const & ec, size_t size_a, nano::message_header const & header_a) +void nano::bootstrap_server::receive_confirm_ack_action (boost::system::error_code const & ec, std::size_t size_a, nano::message_header const & header_a) { if (!ec) { @@ -494,7 +491,7 @@ void nano::bootstrap_server::receive_confirm_ack_action (boost::system::error_co if (!vote_block.which ()) { auto const & block (boost::get> (vote_block)); - if (nano::work_validate_entry (*block)) + if (node->network_params.work.validate_entry (*block)) { process_vote = false; node->stats.inc_detail_only (nano::stat::type::error, nano::stat::detail::insufficient_work); @@ -516,7 +513,7 @@ void nano::bootstrap_server::receive_confirm_ack_action (boost::system::error_co } } -void nano::bootstrap_server::receive_node_id_handshake_action (boost::system::error_code const & ec, size_t size_a, nano::message_header const & header_a) +void nano::bootstrap_server::receive_node_id_handshake_action (boost::system::error_code const & ec, std::size_t size_a, nano::message_header const & header_a) { if (!ec) { @@ -525,7 +522,7 @@ void nano::bootstrap_server::receive_node_id_handshake_action (boost::system::er auto request (std::make_unique (error, stream, header_a)); if (!error) { - if (type == nano::bootstrap_server_type::undefined && !node->flags.disable_tcp_realtime) + if (socket->type () == nano::socket::type_t::undefined && !node->flags.disable_tcp_realtime) { add_request (std::unique_ptr (request.release ())); } @@ -553,21 +550,34 @@ void nano::bootstrap_server::add_request (std::unique_ptr message void nano::bootstrap_server::finish_request () { nano::unique_lock lock (mutex); - requests.pop (); if (!requests.empty ()) { - run_next (lock); + requests.pop (); } else { - std::weak_ptr this_w (shared_from_this ()); - node->workers.add_timed_task (std::chrono::steady_clock::now () + (node->config.tcp_io_timeout * 2) + std::chrono::seconds (1), [this_w] () { - if (auto this_l = this_w.lock ()) - { - this_l->timeout (); - } - }); + node->stats.inc (nano::stat::type::bootstrap, nano::stat::detail::request_underflow); + } + + while (!requests.empty ()) + { + if (!requests.front ()) + { + requests.pop (); + } + else + { + run_next (lock); + } } + + std::weak_ptr this_w (shared_from_this ()); + node->workers.add_timed_task (std::chrono::steady_clock::now () + (node->config.tcp_io_timeout * 2) + std::chrono::seconds (1), [this_w] () { + if (auto this_l = this_w.lock ()) + { + this_l->timeout (); + } + }); } void nano::bootstrap_server::finish_request_async () @@ -583,25 +593,17 @@ void nano::bootstrap_server::finish_request_async () void nano::bootstrap_server::timeout () { - if (socket != nullptr) + if (socket->has_timed_out ()) { - if (socket->has_timed_out ()) + if (node->config.logging.bulk_pull_logging ()) { - if (node->config.logging.bulk_pull_logging ()) - { - node->logger.try_log ("Closing incoming tcp / bootstrap server by timeout"); - } - { - nano::lock_guard lock (node->bootstrap.mutex); - node->bootstrap.connections.erase (this); - } - socket->close (); + node->logger.try_log ("Closing incoming tcp / bootstrap server by timeout"); } - } - else - { - nano::lock_guard lock (node->bootstrap.mutex); - node->bootstrap.connections.erase (this); + { + nano::lock_guard lock (node->bootstrap.mutex); + node->bootstrap.connections.erase (this); + } + socket->close (); } } @@ -616,19 +618,19 @@ class request_response_visitor : public nano::message_visitor } void keepalive (nano::keepalive const & message_a) override { - connection->node->network.tcp_message_manager.put_message (nano::tcp_message_item{ std::make_shared (message_a), connection->remote_endpoint, connection->remote_node_id, connection->socket, connection->type }); + connection->node->network.tcp_message_manager.put_message (nano::tcp_message_item{ std::make_shared (message_a), connection->remote_endpoint, connection->remote_node_id, connection->socket }); } void publish (nano::publish const & message_a) override { - connection->node->network.tcp_message_manager.put_message (nano::tcp_message_item{ std::make_shared (message_a), connection->remote_endpoint, connection->remote_node_id, connection->socket, connection->type }); + connection->node->network.tcp_message_manager.put_message (nano::tcp_message_item{ std::make_shared (message_a), connection->remote_endpoint, connection->remote_node_id, connection->socket }); } void confirm_req (nano::confirm_req const & message_a) override { - connection->node->network.tcp_message_manager.put_message (nano::tcp_message_item{ std::make_shared (message_a), connection->remote_endpoint, connection->remote_node_id, connection->socket, connection->type }); + connection->node->network.tcp_message_manager.put_message (nano::tcp_message_item{ std::make_shared (message_a), connection->remote_endpoint, connection->remote_node_id, connection->socket }); } void confirm_ack (nano::confirm_ack const & message_a) override { - connection->node->network.tcp_message_manager.put_message (nano::tcp_message_item{ std::make_shared (message_a), connection->remote_endpoint, connection->remote_node_id, connection->socket, connection->type }); + connection->node->network.tcp_message_manager.put_message (nano::tcp_message_item{ std::make_shared (message_a), connection->remote_endpoint, connection->remote_node_id, connection->socket }); } void bulk_pull (nano::bulk_pull const &) override { @@ -652,11 +654,11 @@ class request_response_visitor : public nano::message_visitor } void telemetry_req (nano::telemetry_req const & message_a) override { - connection->node->network.tcp_message_manager.put_message (nano::tcp_message_item{ std::make_shared (message_a), connection->remote_endpoint, connection->remote_node_id, connection->socket, connection->type }); + connection->node->network.tcp_message_manager.put_message (nano::tcp_message_item{ std::make_shared (message_a), connection->remote_endpoint, connection->remote_node_id, connection->socket }); } void telemetry_ack (nano::telemetry_ack const & message_a) override { - connection->node->network.tcp_message_manager.put_message (nano::tcp_message_item{ std::make_shared (message_a), connection->remote_endpoint, connection->remote_node_id, connection->socket, connection->type }); + connection->node->network.tcp_message_manager.put_message (nano::tcp_message_item{ std::make_shared (message_a), connection->remote_endpoint, connection->remote_node_id, connection->socket }); } void node_id_handshake (nano::node_id_handshake const & message_a) override { @@ -669,9 +671,9 @@ class request_response_visitor : public nano::message_visitor boost::optional> response (std::make_pair (connection->node->node_id.pub, nano::sign_message (connection->node->node_id.prv, connection->node->node_id.pub, *message_a.query))); debug_assert (!nano::validate_message (response->first, *message_a.query, response->second)); auto cookie (connection->node->network.syn_cookies.assign (nano::transport::map_tcp_to_endpoint (connection->remote_endpoint))); - nano::node_id_handshake response_message (cookie, response); + nano::node_id_handshake response_message (connection->node->network_params.network, cookie, response); auto shared_const_buffer = response_message.to_shared_const_buffer (); - connection->socket->async_write (shared_const_buffer, [connection = std::weak_ptr (connection)] (boost::system::error_code const & ec, size_t size_a) { + connection->socket->async_write (shared_const_buffer, [connection = std::weak_ptr (connection)] (boost::system::error_code const & ec, std::size_t size_a) { if (auto connection_l = connection.lock ()) { if (ec) @@ -697,7 +699,7 @@ class request_response_visitor : public nano::message_visitor if (!connection->node->network.syn_cookies.validate (nano::transport::map_tcp_to_endpoint (connection->remote_endpoint), node_id, message_a.response->second) && node_id != connection->node->node_id.pub) { connection->remote_node_id = node_id; - connection->type = nano::bootstrap_server_type::realtime; + connection->socket->type_set (nano::socket::type_t::realtime); ++connection->node->bootstrap.realtime_count; connection->finish_request_async (); } @@ -712,9 +714,9 @@ class request_response_visitor : public nano::message_visitor connection->finish_request_async (); } nano::account node_id (connection->remote_node_id); - nano::bootstrap_server_type type (connection->type); - debug_assert (node_id.is_zero () || type == nano::bootstrap_server_type::realtime); - connection->node->network.tcp_message_manager.put_message (nano::tcp_message_item{ std::make_shared (message_a), connection->remote_endpoint, connection->remote_node_id, connection->socket, connection->type }); + nano::socket::type_t type = connection->socket->type (); + debug_assert (node_id.is_zero () || type == nano::socket::type_t::realtime); + connection->node->network.tcp_message_manager.put_message (nano::tcp_message_item{ std::make_shared (message_a), connection->remote_endpoint, connection->remote_node_id, connection->socket }); } std::shared_ptr connection; }; @@ -736,33 +738,23 @@ void nano::bootstrap_server::run_next (nano::unique_lock & lock_a) // Realtime auto request (std::move (requests.front ())); requests.pop (); - auto timeout_check (requests.empty ()); lock_a.unlock (); request->visit (visitor); - if (timeout_check) - { - std::weak_ptr this_w (shared_from_this ()); - node->workers.add_timed_task (std::chrono::steady_clock::now () + (node->config.tcp_io_timeout * 2) + std::chrono::seconds (1), [this_w] () { - if (auto this_l = this_w.lock ()) - { - this_l->timeout (); - } - }); - } + lock_a.lock (); } } bool nano::bootstrap_server::is_bootstrap_connection () { - if (type == nano::bootstrap_server_type::undefined && !node->flags.disable_bootstrap_listener && node->bootstrap.bootstrap_count < node->config.bootstrap_connections_max) + if (socket->type () == nano::socket::type_t::undefined && !node->flags.disable_bootstrap_listener && node->bootstrap.bootstrap_count < node->config.bootstrap_connections_max) { ++node->bootstrap.bootstrap_count; - type = nano::bootstrap_server_type::bootstrap; + socket->type_set (nano::socket::type_t::bootstrap); } - return type == nano::bootstrap_server_type::bootstrap; + return socket->type () == nano::socket::type_t::bootstrap; } bool nano::bootstrap_server::is_realtime_connection () { - return type == nano::bootstrap_server_type::realtime || type == nano::bootstrap_server_type::realtime_response_server; + return socket->is_realtime_connection (); } diff --git a/nano/node/bootstrap/bootstrap_server.hpp b/nano/node/bootstrap/bootstrap_server.hpp index b024062146..30fd073f0e 100644 --- a/nano/node/bootstrap/bootstrap_server.hpp +++ b/nano/node/bootstrap/bootstrap_server.hpp @@ -16,7 +16,7 @@ class bootstrap_listener final void start (); void stop (); void accept_action (boost::system::error_code const &, std::shared_ptr const &); - size_t connection_count (); + std::size_t connection_count (); nano::mutex mutex; std::unordered_map> connections; @@ -24,8 +24,8 @@ class bootstrap_listener final nano::node & node; std::shared_ptr listening_socket; bool on{ false }; - std::atomic bootstrap_count{ 0 }; - std::atomic realtime_count{ 0 }; + std::atomic bootstrap_count{ 0 }; + std::atomic realtime_count{ 0 }; private: uint16_t port; @@ -34,13 +34,6 @@ class bootstrap_listener final std::unique_ptr collect_container_info (bootstrap_listener & bootstrap_listener, std::string const & name); class message; -enum class bootstrap_server_type -{ - undefined, - bootstrap, - realtime, - realtime_response_server // special type for tcp channel response server -}; class bootstrap_server final : public std::enable_shared_from_this { public: @@ -48,16 +41,16 @@ class bootstrap_server final : public std::enable_shared_from_this); void finish_request (); void finish_request_async (); @@ -66,15 +59,14 @@ class bootstrap_server final : public std::enable_shared_from_this> receive_buffer; - std::shared_ptr socket; + std::shared_ptr const socket; std::shared_ptr node; nano::mutex mutex; std::queue> requests; std::atomic stopped{ false }; - std::atomic type{ nano::bootstrap_server_type::undefined }; // Remote enpoint used to remove response channel even after socket closing nano::tcp_endpoint remote_endpoint{ boost::asio::ip::address_v6::any (), 0 }; - nano::account remote_node_id{ 0 }; + nano::account remote_node_id{}; std::chrono::steady_clock::time_point last_telemetry_req{ std::chrono::steady_clock::time_point () }; }; } diff --git a/nano/node/cli.cpp b/nano/node/cli.cpp index ead795e988..9f2709347a 100644 --- a/nano/node/cli.cpp +++ b/nano/node/cli.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include @@ -9,7 +10,7 @@ namespace { -void reset_confirmation_heights (nano::write_transaction const & transaction, nano::block_store & store); +void reset_confirmation_heights (nano::write_transaction const & transaction, nano::ledger_constants & constants, nano::store & store); bool is_using_rocksdb (boost::filesystem::path const & data_path, boost::program_options::variables_map const & vm, std::error_code & ec); } @@ -44,6 +45,7 @@ void nano::add_node_options (boost::program_options::options_description & descr { // clang-format off description_a.add_options () + ("initialize", "Initialize the data folder, if it is not already initialised. This command is meant to be run when the data folder is empty, to populate it with the genesis block.") ("account_create", "Insert next deterministic key in to ") ("account_get", "Get account number for the ") ("account_key", "Get the public key for ") @@ -60,7 +62,7 @@ void nano::add_node_options (boost::program_options::options_description & descr ("rebuild_database", "Rebuild LMDB database with vacuum for best compaction") ("migrate_database_lmdb_to_rocksdb", "Migrates LMDB database to RocksDB") ("diagnostics", "Run internal diagnostics") - ("generate_config", boost::program_options::value (), "Write configuration to stdout, populated with defaults suitable for this system. Pass the configuration type node or rpc. See also use_defaults.") + ("generate_config", boost::program_options::value (), "Write configuration to stdout, populated with defaults suitable for this system. Pass the configuration type node, rpc or tls. See also use_defaults.") ("key_create", "Generates a adhoc random keypair and prints it to stdout") ("key_expand", "Derive public key and account number from ") ("wallet_add_adhoc", "Insert in to ") @@ -73,6 +75,9 @@ void nano::add_node_options (boost::program_options::options_description & descr ("wallet_remove", "Remove from ") ("wallet_representative_get", "Prints default representative for ") ("wallet_representative_set", "Set as default representative for ") + ("timestamps_import", "Imports a CSV file, overwriting the timestamps recorded in the database (warning: high resource usage).") + ("timestamps_export", "Writes a CSV file with the local timestamp recorded for each hash with timestamp in the database.") + ("timestamps_update_frontiers", "Updates the 'modified' timestamp of each account chain with the stamps of each frontier") ("all", "Only valid with --final_vote_clear") ("account", boost::program_options::value (), "Defines for other commands") ("root", boost::program_options::value (), "Defines for other commands") @@ -90,10 +95,14 @@ void nano::add_node_flag_options (boost::program_options::options_description & { // clang-format off description_a.add_options() + ("disable_add_initial_peers", "Disable contacting the peer in the peers table at startup") ("disable_backup", "Disable wallet automatic backups") ("disable_lazy_bootstrap", "Disables lazy bootstrap") ("disable_legacy_bootstrap", "Disables legacy bootstrap") ("disable_wallet_bootstrap", "Disables wallet lazy bootstrap") + ("disable_ongoing_bootstrap", "Disable ongoing bootstrap") + ("disable_rep_crawler", "Disable rep crawler") + ("disable_request_loop", "Disable request loop") ("disable_bootstrap_listener", "Disables bootstrap processing for TCP listener (not including realtime network TCP connections)") ("disable_tcp_realtime", "Disables TCP realtime network") ("disable_udp", "(Deprecated) UDP is disabled by default") @@ -117,10 +126,14 @@ void nano::add_node_flag_options (boost::program_options::options_description & std::error_code nano::update_flags (nano::node_flags & flags_a, boost::program_options::variables_map const & vm) { std::error_code ec; + flags_a.disable_add_initial_peers = (vm.count ("disable_add_initial_peers") > 0); flags_a.disable_backup = (vm.count ("disable_backup") > 0); flags_a.disable_lazy_bootstrap = (vm.count ("disable_lazy_bootstrap") > 0); flags_a.disable_legacy_bootstrap = (vm.count ("disable_legacy_bootstrap") > 0); flags_a.disable_wallet_bootstrap = (vm.count ("disable_wallet_bootstrap") > 0); + flags_a.disable_ongoing_bootstrap = (vm.count ("disable_ongoing_bootstrap") > 0); + flags_a.disable_rep_crawler = (vm.count ("disable_rep_crawler") > 0); + flags_a.disable_request_loop = (vm.count ("disable_request_loop") > 0); if (!flags_a.inactive_node) { flags_a.disable_bootstrap_listener = (vm.count ("disable_bootstrap_listener") > 0); @@ -147,32 +160,32 @@ std::error_code nano::update_flags (nano::node_flags & flags_a, boost::program_o flags_a.disable_block_processor_unchecked_deletion = true; flags_a.block_processor_batch_size = 256 * 1024; flags_a.block_processor_full_size = 1024 * 1024; - flags_a.block_processor_verification_size = std::numeric_limits::max (); + flags_a.block_processor_verification_size = std::numeric_limits::max (); } auto block_processor_batch_size_it = vm.find ("block_processor_batch_size"); if (block_processor_batch_size_it != vm.end ()) { - flags_a.block_processor_batch_size = block_processor_batch_size_it->second.as (); + flags_a.block_processor_batch_size = block_processor_batch_size_it->second.as (); } auto block_processor_full_size_it = vm.find ("block_processor_full_size"); if (block_processor_full_size_it != vm.end ()) { - flags_a.block_processor_full_size = block_processor_full_size_it->second.as (); + flags_a.block_processor_full_size = block_processor_full_size_it->second.as (); } auto block_processor_verification_size_it = vm.find ("block_processor_verification_size"); if (block_processor_verification_size_it != vm.end ()) { - flags_a.block_processor_verification_size = block_processor_verification_size_it->second.as (); + flags_a.block_processor_verification_size = block_processor_verification_size_it->second.as (); } auto inactive_votes_cache_size_it = vm.find ("inactive_votes_cache_size"); if (inactive_votes_cache_size_it != vm.end ()) { - flags_a.inactive_votes_cache_size = inactive_votes_cache_size_it->second.as (); + flags_a.inactive_votes_cache_size = inactive_votes_cache_size_it->second.as (); } auto vote_processor_capacity_it = vm.find ("vote_processor_capacity"); if (vote_processor_capacity_it != vm.end ()) { - flags_a.vote_processor_capacity = vote_processor_capacity_it->second.as (); + flags_a.vote_processor_capacity = vote_processor_capacity_it->second.as (); } // Config overriding auto config (vm.find ("config")); @@ -220,7 +233,7 @@ bool copy_database (boost::filesystem::path const & data_path, boost::program_op auto & store (node.node->store); if (vm.count ("unchecked_clear")) { - node.node->store.unchecked_clear (store.tx_begin_write ()); + node.node->store.unchecked.clear (store.tx_begin_write ()); } if (vm.count ("clear_send_ids")) { @@ -228,19 +241,19 @@ bool copy_database (boost::filesystem::path const & data_path, boost::program_op } if (vm.count ("online_weight_clear")) { - node.node->store.online_weight_clear (store.tx_begin_write ()); + node.node->store.online_weight.clear (store.tx_begin_write ()); } if (vm.count ("peer_clear")) { - node.node->store.peer_clear (store.tx_begin_write ()); + node.node->store.peer.clear (store.tx_begin_write ()); } if (vm.count ("confirmation_height_clear")) { - reset_confirmation_heights (store.tx_begin_write (), store); + reset_confirmation_heights (store.tx_begin_write (), node.node->network_params.ledger, store); } if (vm.count ("final_vote_clear")) { - node.node->store.final_vote_clear (store.tx_begin_write ()); + node.node->store.final_vote.clear (store.tx_begin_write ()); } if (vm.count ("rebuild_database")) { @@ -262,7 +275,14 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map std::error_code ec; boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : nano::working_path (); - if (vm.count ("account_create")) + if (vm.count ("initialize")) + { + auto node_flags = nano::inactive_node_flag_defaults (); + node_flags.read_only = false; + nano::update_flags (node_flags, vm); + nano::inactive_node node (data_path, node_flags); + } + else if (vm.count ("account_create")) { if (vm.count ("wallet") == 1) { @@ -398,7 +418,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map std::cerr << "Vacuum failed. RocksDB is enabled but the node has not been built with RocksDB support" << std::endl; } } - catch (const boost::filesystem::filesystem_error & ex) + catch (boost::filesystem::filesystem_error const & ex) { std::cerr << "Vacuum failed during a file operation: " << ex.what () << std::endl; } @@ -445,7 +465,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map std::cerr << "Snapshot failed. RocksDB is enabled but the node has not been built with RocksDB support" << std::endl; } } - catch (const boost::filesystem::filesystem_error & ex) + catch (boost::filesystem::filesystem_error const & ex) { std::cerr << "Snapshot failed during a file operation: " << ex.what () << std::endl; } @@ -491,7 +511,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map if (!node.node->init_error ()) { auto transaction (node.node->store.tx_begin_write ()); - node.node->store.unchecked_clear (transaction); + node.node->store.unchecked.clear (transaction); std::cout << "Unchecked blocks deleted" << std::endl; } else @@ -527,8 +547,8 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map if (!node.node->init_error ()) { auto transaction (node.node->store.tx_begin_write ()); - node.node->store.online_weight_clear (transaction); - std::cout << "Onine weight records are removed" << std::endl; + node.node->store.online_weight.clear (transaction); + std::cout << "Online weight records are removed" << std::endl; } else { @@ -545,7 +565,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map if (!node.node->init_error ()) { auto transaction (node.node->store.tx_begin_write ()); - node.node->store.peer_clear (transaction); + node.node->store.peer.clear (transaction); std::cout << "Database peers are removed" << std::endl; } else @@ -570,18 +590,18 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map if (!account.decode_account (account_str)) { nano::confirmation_height_info confirmation_height_info; - if (!node.node->store.confirmation_height_get (node.node->store.tx_begin_read (), account, confirmation_height_info)) + if (!node.node->store.confirmation_height.get (node.node->store.tx_begin_read (), account, confirmation_height_info)) { auto transaction (node.node->store.tx_begin_write ()); auto conf_height_reset_num = 0; - if (account == node.node->network_params.ledger.genesis_account) + if (account == node.node->network_params.ledger.genesis->account ()) { conf_height_reset_num = 1; - node.node->store.confirmation_height_put (transaction, account, { confirmation_height_info.height, node.node->network_params.ledger.genesis_block }); + node.node->store.confirmation_height.put (transaction, account, { confirmation_height_info.height, node.node->network_params.ledger.genesis->hash () }); } else { - node.node->store.confirmation_height_clear (transaction, account); + node.node->store.confirmation_height.clear (transaction, account); } std::cout << "Confirmation height of account " << account_str << " is set to " << conf_height_reset_num << std::endl; @@ -601,7 +621,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map else { auto transaction (node.node->store.tx_begin_write ()); - reset_confirmation_heights (transaction, node.node->store); + reset_confirmation_heights (transaction, node.node->network_params.ledger, node.node->store); std::cout << "Confirmation heights of all accounts (except genesis which is set to 1) are set to 0" << std::endl; } } @@ -626,7 +646,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map nano::root root; if (!root.decode_hex (root_str)) { - node.node->store.final_vote_clear (transaction, root); + node.node->store.final_vote.clear (transaction, root); std::cout << "Successfully cleared final votes" << std::endl; } else @@ -637,7 +657,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map } else if (vm.count ("all")) { - node.node->store.final_vote_clear (node.node->store.tx_begin_write ()); + node.node->store.final_vote.clear (node.node->store.tx_begin_write ()); std::cout << "All final votes are cleared" << std::endl; } else @@ -658,13 +678,20 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map if (type == "node") { valid_type = true; - nano::daemon_config config (data_path); + nano::network_params network_params{ nano::network_constants::active_network }; + nano::daemon_config config{ data_path, network_params }; config.serialize_toml (toml); } else if (type == "rpc") { valid_type = true; - nano::rpc_config config; + nano::rpc_config config{ nano::dev::network_params.network }; + config.serialize_toml (toml); + } + else if (type == "tls") + { + valid_type = true; + nano::tls_config config; config.serialize_toml (toml); } else @@ -702,7 +729,7 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map nano::raw_key junk1; junk1.clear (); nano::uint256_union junk2 (0); - nano::kdf kdf; + nano::kdf kdf{ inactive_node->node->config.network_params.kdf_work }; kdf.phs (junk1, "", junk2); std::cout << "Testing time retrieval latency... " << std::flush; nano::timer timer (nano::timer_state::started); @@ -1283,9 +1310,195 @@ std::error_code nano::handle_node_options (boost::program_options::variables_map ec = nano::error_cli::invalid_arguments; } } - else + else if (vm.count ("timestamps_import") == 1) + { + if (vm.count ("file") == 1) + { + auto inactive_node = nano::default_inactive_node(data_path, vm); + std::string filename (vm["file"].as ()); + std::ifstream stream; + stream.open (filename.c_str ()); + if (!stream.fail ()) + { + std::cout << "Importing timestamps from " << filename << std::endl; + std::cout << "This may take a while..." << std::endl; + + boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : nano::working_path (); + auto transaction (inactive_node->node->store.tx_begin_read ()); + std::vector> pairs; + pairs.reserve (inactive_node->node->store.block.count(transaction)); + + std::cout << "Reading file..." << std::endl; + std::stringstream contents; + contents << stream.rdbuf (); + std::string line, hash, timestamp; + try + { + while (std::getline (contents, line, '\n')) + { + std::istringstream liness (line); + if (std::getline (liness, hash, ',') && std::getline (liness, timestamp, ',')) + { + pairs.push_back (std::make_pair (nano::block_hash (hash), std::stoull (timestamp))); + } + else + { + std::cerr << "Failure while reading the file, in line " << pairs.size () + 1 << std::endl; + ec = nano::error_cli::generic; + break; + } + } + } + catch (const std::invalid_argument & ex) + { + std::cerr << "Failure while reading the file, timestamp is invalid in line " << pairs.size () + 1 << std::endl; + ec = nano::error_cli::generic; + } + catch (const std::out_of_range & ex) + { + std::cerr << "Failure while reading the file, timestamp is invalid in line " << pairs.size () + 1 << std::endl; + ec = nano::error_cli::generic; + } + catch (...) + { + std::cerr << "Unknown error while reading the file, in line " << pairs.size () + 1 << std::endl; + ec = nano::error_cli::generic; + } + + stream.close (); + if (!ec) + { + std::cout << "Upgrading database..." << std::endl; + + auto block_count (pairs.size ()); + size_t count{ 0 }; + size_t step (std::max (10, std::pow (10.0f, std::floor (std::log10 (block_count / 10.0))))); + auto transaction (inactive_node->node->store.tx_begin_write ()); + for (auto i (pairs.begin ()), n (pairs.end ()); i != n; ++i, ++count) + { + auto block (inactive_node->node->store.block.get(transaction, i->first)); + if (block) + { + auto sideband_with_stamp = block->sideband (); + sideband_with_stamp.timestamp = i->second; + block->sideband_set (sideband_with_stamp); + inactive_node->node->store.block.put (transaction, i->first, *block); + + if (count > 0 && count % step == 0 || count == block_count) + { + std::cout << count << "/" << block_count << std::endl; + } + } + else + { + std::cerr << "Skipping hash not in database: " << i->first.to_string () << std::endl; + } + } + std::cout << "Completed importing timestamps" << std::endl; + } + } + else + { + std::cerr << "Unable to open \n"; + ec = nano::error_cli::invalid_arguments; + } + } + else + { + std::cerr << "timestamps_import requires one option\n"; + ec = nano::error_cli::invalid_arguments; + } + } + else if (vm.count ("timestamps_export") == 1) { - ec = nano::error_cli::unknown_command; + auto inactive_node = nano::default_inactive_node(data_path, vm); + + boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : nano::working_path (); + auto timestamps_path = data_path / "timestamps.csv"; + + std::cout << "Exporting timestamps in " << data_path << std::endl; + std::cout << "This may take a while..." << std::endl; + + auto transaction (inactive_node->node->store.tx_begin_read ()); + auto accounts (inactive_node->node->store.account.count (transaction)); + if (accounts > 0) + { + size_t count{ 0 }; + size_t step (std::max (10, std::pow (10.0f, std::floor (std::log10 (accounts / 10.0))))); + std::vector> pairs; + pairs.reserve (inactive_node->node->store.block.count (transaction)); + + std::cout << "Reading database..." << std::endl; + + for (auto i (inactive_node->node->store.account.begin (transaction)), n (inactive_node->node->store.account.end ()); i != n; ++i, ++count) + { + auto hash (i->second.head); + auto block (inactive_node->node->store.block.get (transaction, hash)); + while (block != nullptr) + { + if (block->sideband ().timestamp != 0) + { + pairs.push_back (std::make_pair (hash, block->sideband ().timestamp)); + } + hash = block->previous (); + block = inactive_node->node->store.block.get (transaction, hash); + } + if (count > 0 && count % step == 0 || count == accounts) + { + std::cout << count << "/" << accounts << std::endl; + } + } + if (pairs.empty ()) + { + std::cout << "No timestamps found in the database" << std::endl; + } + else + { + try + { + boost::filesystem::ofstream stream{ timestamps_path }; + std::cout << "Writing to file..." << std::endl; + for (auto & pair : pairs) + { + stream << pair.first.to_string () << "," << pair.second << std::endl; + } + std::cout << "Completed exporting timestamps, the file can be found in " << timestamps_path << std::endl; + } + catch (const boost::filesystem::filesystem_error & ex) + { + std::cerr << "Timestamps export failed during a file operation: " << ex.what () << std::endl; + } + catch (...) + { + std::cerr << "Timestamps export failed (unknown reason)" << std::endl; + } + } + } + else + { + std::cout << "Empty database" << std::endl; + } + } + else if (vm.count ("timestamps_update_frontiers") == 1) + { + auto inactive_node = nano::default_inactive_node(data_path, vm); + + boost::filesystem::path data_path = vm.count ("data_path") ? boost::filesystem::path (vm["data_path"].as ()) : nano::working_path (); + + std::cout << "Updating account information..." << std::endl; + + auto transaction (inactive_node->node->store.tx_begin_write ()); + + for (auto i (inactive_node->node->store.account.begin (transaction)), n (inactive_node->node->store.account.end ()); i != n; ++i) + { + auto block (inactive_node->node->store.block.get (transaction, i->second.head)); + i->second.modified = block->sideband ().timestamp; + inactive_node->node->store.account.put (transaction, i->first, i->second); + } + } + else + { + ec = nano::error_cli::unknown_command; } return ec; @@ -1300,19 +1513,19 @@ std::unique_ptr nano::default_inactive_node (boost::filesys namespace { -void reset_confirmation_heights (nano::write_transaction const & transaction, nano::block_store & store) +void reset_confirmation_heights (nano::write_transaction const & transaction, nano::ledger_constants & constants, nano::store & store) { // First do a clean sweep - store.confirmation_height_clear (transaction); + store.confirmation_height.clear (transaction); // Then make sure the confirmation height of the genesis account open block is 1 - nano::network_params network_params; - store.confirmation_height_put (transaction, network_params.ledger.genesis_account, { 1, network_params.ledger.genesis_hash }); + store.confirmation_height.put (transaction, constants.genesis->account (), { 1, constants.genesis->hash () }); } bool is_using_rocksdb (boost::filesystem::path const & data_path, boost::program_options::variables_map const & vm, std::error_code & ec) { - nano::daemon_config config (data_path); + nano::network_params network_params{ nano::network_constants::active_network }; + nano::daemon_config config{ data_path, network_params }; // Config overriding auto config_arg (vm.find ("config")); diff --git a/nano/node/common.cpp b/nano/node/common.cpp index 86067c4790..f4cbc7a144 100644 --- a/nano/node/common.cpp +++ b/nano/node/common.cpp @@ -21,25 +21,15 @@ std::chrono::seconds constexpr nano::telemetry_cache_cutoffs::dev; std::chrono::seconds constexpr nano::telemetry_cache_cutoffs::beta; std::chrono::seconds constexpr nano::telemetry_cache_cutoffs::live; -namespace -{ -nano::protocol_constants const & get_protocol_constants () -{ - static nano::network_params params; - return params.protocol; -} -} - uint64_t nano::ip_address_hash_raw (boost::asio::ip::address const & ip_a, uint16_t port) { - static nano::random_constants constants; debug_assert (ip_a.is_v6 ()); uint64_t result; nano::uint128_union address; address.bytes = ip_a.to_v6 ().to_bytes (); blake2b_state state; blake2b_init (&state, sizeof (result)); - blake2b_update (&state, constants.random_128.bytes.data (), constants.random_128.bytes.size ()); + blake2b_update (&state, nano::hardened_constants::get ().random_128.bytes.data (), nano::hardened_constants::get ().random_128.bytes.size ()); if (port != 0) { blake2b_update (&state, &port, sizeof (port)); @@ -49,9 +39,11 @@ uint64_t nano::ip_address_hash_raw (boost::asio::ip::address const & ip_a, uint1 return result; } -nano::message_header::message_header (nano::message_type type_a) : - version_max (get_protocol_constants ().protocol_version), - version_using (get_protocol_constants ().protocol_version), +nano::message_header::message_header (nano::network_constants const & constants, nano::message_type type_a) : + network{ constants.current_network }, + version_max{ constants.protocol_version }, + version_using{ constants.protocol_version }, + version_min{ constants.protocol_version_min }, type (type_a) { } @@ -66,11 +58,10 @@ nano::message_header::message_header (bool & error_a, nano::stream & stream_a) void nano::message_header::serialize (nano::stream & stream_a) const { - static nano::network_params network_params; - nano::write (stream_a, network_params.header_magic_number); + nano::write (stream_a, boost::endian::native_to_big (static_cast (network))); nano::write (stream_a, version_max); nano::write (stream_a, version_using); - nano::write (stream_a, get_protocol_constants ().protocol_version_min ()); + nano::write (stream_a, version_min); nano::write (stream_a, type); nano::write (stream_a, static_cast (extensions.to_ullong ())); } @@ -80,19 +71,14 @@ bool nano::message_header::deserialize (nano::stream & stream_a) auto error (false); try { - static nano::network_params network_params; - uint16_t extensions_l; - std::array magic_number_l; - read (stream_a, magic_number_l); - if (magic_number_l != network_params.header_magic_number) - { - throw std::runtime_error ("Magic numbers do not match"); - } - + uint16_t network_bytes; + nano::read (stream_a, network_bytes); + network = static_cast (boost::endian::big_to_native (network_bytes)); nano::read (stream_a, version_max); nano::read (stream_a, version_using); - nano::read (stream_a, version_min_m); + nano::read (stream_a, version_min); nano::read (stream_a, type); + uint16_t extensions_l; nano::read (stream_a, extensions_l); extensions = extensions_l; } @@ -104,14 +90,8 @@ bool nano::message_header::deserialize (nano::stream & stream_a) return error; } -uint8_t nano::message_header::version_min () const -{ - debug_assert (version_min_m != std::numeric_limits::max ()); - return version_min_m; -} - -nano::message::message (nano::message_type type_a) : - header (type_a) +nano::message::message (nano::network_constants const & constants, nano::message_type type_a) : + header (constants, type_a) { } @@ -215,7 +195,7 @@ bool nano::message_header::node_id_handshake_is_response () const return result; } -size_t nano::message_header::payload_length_bytes () const +std::size_t nano::message_header::payload_length_bytes () const { switch (type) { @@ -270,7 +250,7 @@ size_t nano::message_header::payload_length_bytes () const } // MTU - IP header - UDP header -const size_t nano::message_parser::max_safe_udp_message_size = 508; +std::size_t const nano::message_parser::max_safe_udp_message_size = 508; std::string nano::message_parser::status_string () { @@ -335,19 +315,19 @@ std::string nano::message_parser::status_string () return "[unknown parse_status]"; } -nano::message_parser::message_parser (nano::network_filter & publish_filter_a, nano::block_uniquer & block_uniquer_a, nano::vote_uniquer & vote_uniquer_a, nano::message_visitor & visitor_a, nano::work_pool & pool_a) : +nano::message_parser::message_parser (nano::network_filter & publish_filter_a, nano::block_uniquer & block_uniquer_a, nano::vote_uniquer & vote_uniquer_a, nano::message_visitor & visitor_a, nano::work_pool & pool_a, nano::network_constants const & network) : publish_filter (publish_filter_a), block_uniquer (block_uniquer_a), vote_uniquer (vote_uniquer_a), visitor (visitor_a), pool (pool_a), - status (parse_status::success) + status (parse_status::success), + network{ network } { } -void nano::message_parser::deserialize_buffer (uint8_t const * buffer_a, size_t size_a) +void nano::message_parser::deserialize_buffer (uint8_t const * buffer_a, std::size_t size_a) { - static nano::network_constants network_constants; status = parse_status::success; auto error (false); if (size_a <= max_safe_udp_message_size) @@ -357,7 +337,7 @@ void nano::message_parser::deserialize_buffer (uint8_t const * buffer_a, size_t nano::message_header header (error, stream); if (!error) { - if (header.version_using < get_protocol_constants ().protocol_version_min ()) + if (header.version_using < network.protocol_version_min) { status = parse_status::outdated_version; } @@ -443,7 +423,7 @@ void nano::message_parser::deserialize_publish (nano::stream & stream_a, nano::m nano::publish incoming (error, stream_a, header_a, digest_a, &block_uniquer); if (!error && at_end (stream_a)) { - if (!nano::work_validate_entry (*incoming.block)) + if (!network.work.validate_entry (*incoming.block)) { visitor.publish (incoming); } @@ -464,7 +444,7 @@ void nano::message_parser::deserialize_confirm_req (nano::stream & stream_a, nan nano::confirm_req incoming (error, stream_a, header_a, &block_uniquer); if (!error && at_end (stream_a)) { - if (incoming.block == nullptr || !nano::work_validate_entry (*incoming.block)) + if (incoming.block == nullptr || !network.work.validate_entry (*incoming.block)) { visitor.confirm_req (incoming); } @@ -490,7 +470,7 @@ void nano::message_parser::deserialize_confirm_ack (nano::stream & stream_a, nan if (!vote_block.which ()) { auto const & block (boost::get> (vote_block)); - if (nano::work_validate_entry (*block)) + if (network.work.validate_entry (*block)) { status = parse_status::insufficient_work; break; @@ -557,8 +537,8 @@ bool nano::message_parser::at_end (nano::stream & stream_a) return end; } -nano::keepalive::keepalive () : - message (nano::message_type::keepalive) +nano::keepalive::keepalive (nano::network_constants const & constants) : + message (constants, nano::message_type::keepalive) { nano::endpoint endpoint (boost::asio::ip::address_v6{}, 0); for (auto i (peers.begin ()), n (peers.end ()); i != n; ++i) @@ -628,8 +608,8 @@ nano::publish::publish (bool & error_a, nano::stream & stream_a, nano::message_h } } -nano::publish::publish (std::shared_ptr const & block_a) : - message (nano::message_type::publish), +nano::publish::publish (nano::network_constants const & constants, std::shared_ptr const & block_a) : + message (constants, nano::message_type::publish), block (block_a) { header.block_type_set (block->type ()); @@ -669,15 +649,15 @@ nano::confirm_req::confirm_req (bool & error_a, nano::stream & stream_a, nano::m } } -nano::confirm_req::confirm_req (std::shared_ptr const & block_a) : - message (nano::message_type::confirm_req), +nano::confirm_req::confirm_req (nano::network_constants const & constants, std::shared_ptr const & block_a) : + message (constants, nano::message_type::confirm_req), block (block_a) { header.block_type_set (block->type ()); } -nano::confirm_req::confirm_req (std::vector> const & roots_hashes_a) : - message (nano::message_type::confirm_req), +nano::confirm_req::confirm_req (nano::network_constants const & constants, std::vector> const & roots_hashes_a) : + message (constants, nano::message_type::confirm_req), roots_hashes (roots_hashes_a) { // not_a_block (1) block type for hashes + roots request @@ -686,8 +666,8 @@ nano::confirm_req::confirm_req (std::vector (roots_hashes.size ())); } -nano::confirm_req::confirm_req (nano::block_hash const & hash_a, nano::root const & root_a) : - message (nano::message_type::confirm_req), +nano::confirm_req::confirm_req (nano::network_constants const & constants, nano::block_hash const & hash_a, nano::root const & root_a) : + message (constants, nano::message_type::confirm_req), roots_hashes (std::vector> (1, std::make_pair (hash_a, root_a))) { debug_assert (!roots_hashes.empty ()); @@ -751,7 +731,7 @@ bool nano::confirm_req::deserialize (nano::stream & stream_a, nano::block_unique result = block == nullptr; } } - catch (const std::runtime_error &) + catch (std::runtime_error const &) { result = true; } @@ -786,9 +766,9 @@ std::string nano::confirm_req::roots_string () const return result; } -size_t nano::confirm_req::size (nano::block_type type_a, size_t count) +std::size_t nano::confirm_req::size (nano::block_type type_a, std::size_t count) { - size_t result (0); + std::size_t result (0); if (type_a != nano::block_type::invalid && type_a != nano::block_type::not_a_block) { result = nano::block::size (type_a); @@ -810,8 +790,8 @@ nano::confirm_ack::confirm_ack (bool & error_a, nano::stream & stream_a, nano::m } } -nano::confirm_ack::confirm_ack (std::shared_ptr const & vote_a) : - message (nano::message_type::confirm_ack), +nano::confirm_ack::confirm_ack (nano::network_constants const & constants, std::shared_ptr const & vote_a) : + message (constants, nano::message_type::confirm_ack), vote (vote_a) { debug_assert (!vote_a->blocks.empty ()); @@ -846,9 +826,9 @@ void nano::confirm_ack::visit (nano::message_visitor & visitor_a) const visitor_a.confirm_ack (*this); } -size_t nano::confirm_ack::size (nano::block_type type_a, size_t count) +std::size_t nano::confirm_ack::size (nano::block_type type_a, std::size_t count) { - size_t result (sizeof (nano::account) + sizeof (nano::signature) + sizeof (uint64_t)); + std::size_t result (sizeof (nano::account) + sizeof (nano::signature) + sizeof (uint64_t)); if (type_a != nano::block_type::invalid && type_a != nano::block_type::not_a_block) { result += nano::block::size (type_a); @@ -860,8 +840,8 @@ size_t nano::confirm_ack::size (nano::block_type type_a, size_t count) return result; } -nano::frontier_req::frontier_req () : - message (nano::message_type::frontier_req) +nano::frontier_req::frontier_req (nano::network_constants const & constants) : + message (constants, nano::message_type::frontier_req) { } @@ -910,8 +890,8 @@ 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) +nano::bulk_pull::bulk_pull (nano::network_constants const & constants) : + message (constants, nano::message_type::bulk_pull) { } @@ -1006,8 +986,8 @@ 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 (nano::network_constants const & constants) : + message (constants, nano::message_type::bulk_pull_account) { } @@ -1051,8 +1031,8 @@ bool nano::bulk_pull_account::deserialize (nano::stream & stream_a) return error; } -nano::bulk_push::bulk_push () : - message (nano::message_type::bulk_push) +nano::bulk_push::bulk_push (nano::network_constants const & constants) : + message (constants, nano::message_type::bulk_push) { } @@ -1077,8 +1057,8 @@ void nano::bulk_push::visit (nano::message_visitor & visitor_a) const visitor_a.bulk_push (*this); } -nano::telemetry_req::telemetry_req () : - message (nano::message_type::telemetry_req) +nano::telemetry_req::telemetry_req (nano::network_constants const & constants) : + message (constants, nano::message_type::telemetry_req) { } @@ -1103,8 +1083,8 @@ void nano::telemetry_req::visit (nano::message_visitor & visitor_a) const visitor_a.telemetry_req (*this); } -nano::telemetry_ack::telemetry_ack () : - message (nano::message_type::telemetry_ack) +nano::telemetry_ack::telemetry_ack (nano::network_constants const & constants) : + message (constants, nano::message_type::telemetry_ack) { } @@ -1117,8 +1097,8 @@ nano::telemetry_ack::telemetry_ack (bool & error_a, nano::stream & stream_a, nan } } -nano::telemetry_ack::telemetry_ack (nano::telemetry_data const & telemetry_data_a) : - message (nano::message_type::telemetry_ack), +nano::telemetry_ack::telemetry_ack (nano::network_constants const & constants, nano::telemetry_data const & telemetry_data_a) : + message (constants, nano::message_type::telemetry_ack), data (telemetry_data_a) { debug_assert (telemetry_data::size + telemetry_data_a.unknown_data.size () <= message_header::telemetry_size_mask.to_ulong ()); // Maximum size the mask allows @@ -1364,8 +1344,8 @@ nano::node_id_handshake::node_id_handshake (bool & error_a, nano::stream & strea error_a = deserialize (stream_a); } -nano::node_id_handshake::node_id_handshake (boost::optional query, boost::optional> response) : - message (nano::message_type::node_id_handshake), +nano::node_id_handshake::node_id_handshake (nano::network_constants const & constants, boost::optional query, boost::optional> response) : + message (constants, nano::message_type::node_id_handshake), query (query), response (response) { @@ -1434,14 +1414,14 @@ void nano::node_id_handshake::visit (nano::message_visitor & visitor_a) const visitor_a.node_id_handshake (*this); } -size_t nano::node_id_handshake::size () const +std::size_t nano::node_id_handshake::size () const { return size (header); } -size_t nano::node_id_handshake::size (nano::message_header const & header_a) +std::size_t nano::node_id_handshake::size (nano::message_header const & header_a) { - size_t result (0); + std::size_t result (0); if (header_a.node_id_handshake_is_query ()) { result = sizeof (nano::uint256_union); @@ -1554,7 +1534,8 @@ bool nano::parse_tcp_endpoint (std::string const & string, nano::tcp_endpoint & std::chrono::seconds nano::telemetry_cache_cutoffs::network_to_time (network_constants const & network_constants) { - return std::chrono::seconds{ (network_constants.is_live_network () || network_constants.is_test_network ()) ? live : network_constants.is_beta_network () ? beta : dev }; + return std::chrono::seconds{ (network_constants.is_live_network () || network_constants.is_test_network ()) ? live : network_constants.is_beta_network () ? beta + : dev }; } nano::node_singleton_memory_pool_purge_guard::node_singleton_memory_pool_purge_guard () : diff --git a/nano/node/common.hpp b/nano/node/common.hpp index 030e95df2a..6f242249fd 100644 --- a/nano/node/common.hpp +++ b/nano/node/common.hpp @@ -36,18 +36,18 @@ uint64_t endpoint_hash_raw (nano::tcp_endpoint const & endpoint_a) return result; } -template +template struct endpoint_hash { }; template <> struct endpoint_hash<8> { - size_t operator() (nano::endpoint const & endpoint_a) const + std::size_t operator() (nano::endpoint const & endpoint_a) const { return endpoint_hash_raw (endpoint_a); } - size_t operator() (nano::tcp_endpoint const & endpoint_a) const + std::size_t operator() (nano::tcp_endpoint const & endpoint_a) const { return endpoint_hash_raw (endpoint_a); } @@ -55,27 +55,27 @@ struct endpoint_hash<8> template <> struct endpoint_hash<4> { - size_t operator() (nano::endpoint const & endpoint_a) const + std::size_t operator() (nano::endpoint const & endpoint_a) const { uint64_t big (endpoint_hash_raw (endpoint_a)); uint32_t result (static_cast (big) ^ static_cast (big >> 32)); return result; } - size_t operator() (nano::tcp_endpoint const & endpoint_a) const + std::size_t operator() (nano::tcp_endpoint const & endpoint_a) const { uint64_t big (endpoint_hash_raw (endpoint_a)); uint32_t result (static_cast (big) ^ static_cast (big >> 32)); return result; } }; -template +template struct ip_address_hash { }; template <> struct ip_address_hash<8> { - size_t operator() (boost::asio::ip::address const & ip_address_a) const + std::size_t operator() (boost::asio::ip::address const & ip_address_a) const { return nano::ip_address_hash_raw (ip_address_a); } @@ -83,7 +83,7 @@ struct ip_address_hash<8> template <> struct ip_address_hash<4> { - size_t operator() (boost::asio::ip::address const & ip_address_a) const + std::size_t operator() (boost::asio::ip::address const & ip_address_a) const { uint64_t big (nano::ip_address_hash_raw (ip_address_a)); uint32_t result (static_cast (big) ^ static_cast (big >> 32)); @@ -97,37 +97,39 @@ namespace std template <> struct hash<::nano::endpoint> { - size_t operator() (::nano::endpoint const & endpoint_a) const + std::size_t operator() (::nano::endpoint const & endpoint_a) const { - endpoint_hash ehash; + endpoint_hash ehash; return ehash (endpoint_a); } }; template <> struct hash<::nano::tcp_endpoint> { - size_t operator() (::nano::tcp_endpoint const & endpoint_a) const + std::size_t operator() (::nano::tcp_endpoint const & endpoint_a) const { - endpoint_hash ehash; + endpoint_hash ehash; return ehash (endpoint_a); } }; +#ifndef BOOST_ASIO_HAS_STD_HASH template <> struct hash { - size_t operator() (boost::asio::ip::address const & ip_a) const + std::size_t operator() (boost::asio::ip::address const & ip_a) const { - ip_address_hash ihash; + ip_address_hash ihash; return ihash (ip_a); } }; +#endif } namespace boost { template <> struct hash<::nano::endpoint> { - size_t operator() (::nano::endpoint const & endpoint_a) const + std::size_t operator() (::nano::endpoint const & endpoint_a) const { std::hash<::nano::endpoint> hash; return hash (endpoint_a); @@ -136,7 +138,7 @@ struct hash<::nano::endpoint> template <> struct hash<::nano::tcp_endpoint> { - size_t operator() (::nano::tcp_endpoint const & endpoint_a) const + std::size_t operator() (::nano::tcp_endpoint const & endpoint_a) const { std::hash<::nano::tcp_endpoint> hash; return hash (endpoint_a); @@ -145,7 +147,7 @@ struct hash<::nano::tcp_endpoint> template <> struct hash { - size_t operator() (boost::asio::ip::address const & ip_a) const + std::size_t operator() (boost::asio::ip::address const & ip_a) const { std::hash hash; return hash (ip_a); @@ -187,7 +189,7 @@ class message_visitor; class message_header final { public: - explicit message_header (nano::message_type); + message_header (nano::network_constants const &, nano::message_type); message_header (bool &, nano::stream &); void serialize (nano::stream &) const; bool deserialize (nano::stream &); @@ -195,16 +197,15 @@ class message_header final void block_type_set (nano::block_type); uint8_t count_get () const; void count_set (uint8_t); + nano::networks network; uint8_t version_max; uint8_t version_using; - -private: - uint8_t version_min_m{ std::numeric_limits::max () }; + uint8_t version_min; public: nano::message_type type; std::bitset<16> extensions; - static size_t constexpr size = sizeof (network_params::header_magic_number) + sizeof (version_max) + sizeof (version_using) + sizeof (version_min_m) + sizeof (type) + sizeof (/* extensions */ uint16_t); + static std::size_t constexpr size = sizeof (nano::networks) + sizeof (version_max) + sizeof (version_using) + sizeof (version_min) + sizeof (type) + sizeof (/* extensions */ uint16_t); void flag_set (uint8_t); static uint8_t constexpr bulk_pull_count_present_flag = 0; @@ -215,10 +216,9 @@ class message_header final static uint8_t constexpr node_id_handshake_response_flag = 1; bool node_id_handshake_is_query () const; bool node_id_handshake_is_response () const; - uint8_t version_min () const; /** Size of the payload in bytes. For some messages, the payload size is based on header flags. */ - size_t payload_length_bytes () const; + std::size_t payload_length_bytes () const; static std::bitset<16> constexpr block_type_mask{ 0x0f00 }; static std::bitset<16> constexpr count_mask{ 0xf000 }; @@ -227,7 +227,7 @@ class message_header final class message { public: - explicit message (nano::message_type); + explicit message (nano::network_constants const &, nano::message_type); explicit message (nano::message_header const &); virtual ~message () = default; virtual void serialize (nano::stream &) const = 0; @@ -238,6 +238,7 @@ class message nano::message_header header; }; class work_pool; +class network_constants; class message_parser final { public: @@ -257,8 +258,8 @@ class message_parser final outdated_version, duplicate_publish_message }; - message_parser (nano::network_filter &, nano::block_uniquer &, nano::vote_uniquer &, nano::message_visitor &, nano::work_pool &); - void deserialize_buffer (uint8_t const *, size_t); + message_parser (nano::network_filter &, nano::block_uniquer &, nano::vote_uniquer &, nano::message_visitor &, nano::work_pool &, nano::network_constants const & protocol); + void deserialize_buffer (uint8_t const *, std::size_t); void deserialize_keepalive (nano::stream &, nano::message_header const &); void deserialize_publish (nano::stream &, nano::message_header const &, nano::uint128_t const & = 0); void deserialize_confirm_req (nano::stream &, nano::message_header const &); @@ -273,26 +274,27 @@ class message_parser final nano::message_visitor & visitor; nano::work_pool & pool; parse_status status; + nano::network_constants const & network; std::string status_string (); - static const size_t max_safe_udp_message_size; + static std::size_t const max_safe_udp_message_size; }; class keepalive final : public message { public: - keepalive (); + explicit keepalive (nano::network_constants const & constants); keepalive (bool &, nano::stream &, nano::message_header const &); void visit (nano::message_visitor &) const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &); bool operator== (nano::keepalive const &) const; std::array peers; - static size_t constexpr size = 8 * (16 + 2); + static std::size_t constexpr size = 8 * (16 + 2); }; class publish final : public message { public: publish (bool &, nano::stream &, nano::message_header const &, nano::uint128_t const & = 0, nano::block_uniquer * = nullptr); - explicit publish (std::shared_ptr const &); + publish (nano::network_constants const & constants, std::shared_ptr const &); void visit (nano::message_visitor &) const override; void serialize (nano::stream &) const override; bool deserialize (nano::stream &, nano::block_uniquer * = nullptr); @@ -304,9 +306,9 @@ class confirm_req final : public message { public: confirm_req (bool &, nano::stream &, nano::message_header const &, nano::block_uniquer * = nullptr); - explicit confirm_req (std::shared_ptr const &); - confirm_req (std::vector> const &); - confirm_req (nano::block_hash const &, nano::root const &); + confirm_req (nano::network_constants const & constants, std::shared_ptr const &); + confirm_req (nano::network_constants const & constants, std::vector> const &); + confirm_req (nano::network_constants const & constants, nano::block_hash const &, nano::root const &); void serialize (nano::stream &) const override; bool deserialize (nano::stream &, nano::block_uniquer * = nullptr); void visit (nano::message_visitor &) const override; @@ -314,23 +316,23 @@ class confirm_req final : public message std::shared_ptr block; std::vector> roots_hashes; std::string roots_string () const; - static size_t size (nano::block_type, size_t = 0); + static std::size_t size (nano::block_type, std::size_t = 0); }; class confirm_ack final : public message { public: confirm_ack (bool &, nano::stream &, nano::message_header const &, nano::vote_uniquer * = nullptr); - explicit confirm_ack (std::shared_ptr const &); + confirm_ack (nano::network_constants const & constants, std::shared_ptr const &); void serialize (nano::stream &) const override; void visit (nano::message_visitor &) const override; bool operator== (nano::confirm_ack const &) const; std::shared_ptr vote; - static size_t size (nano::block_type, size_t = 0); + static std::size_t size (nano::block_type, std::size_t = 0); }; class frontier_req final : public message { public: - frontier_req (); + explicit frontier_req (nano::network_constants const & constants); frontier_req (bool &, nano::stream &, nano::message_header const &); void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -339,7 +341,7 @@ class frontier_req final : public message nano::account start; uint32_t age; uint32_t count; - static size_t constexpr size = sizeof (start) + sizeof (age) + sizeof (count); + static std::size_t constexpr size = sizeof (start) + sizeof (age) + sizeof (count); }; enum class telemetry_maker : uint8_t @@ -352,7 +354,7 @@ class telemetry_data { public: nano::signature signature{ 0 }; - nano::account node_id{ 0 }; + nano::account node_id{}; uint64_t block_count{ 0 }; uint64_t cemented_count{ 0 }; uint64_t unchecked_count{ 0 }; @@ -389,7 +391,7 @@ class telemetry_data class telemetry_req final : public message { public: - telemetry_req (); + explicit telemetry_req (nano::network_constants const & constants); explicit telemetry_req (nano::message_header const &); void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -398,9 +400,9 @@ class telemetry_req final : public message class telemetry_ack final : public message { public: - telemetry_ack (); + explicit telemetry_ack (nano::network_constants const & constants); telemetry_ack (bool &, nano::stream &, nano::message_header const &); - explicit telemetry_ack (telemetry_data const &); + telemetry_ack (nano::network_constants const & constants, telemetry_data const &); void serialize (nano::stream &) const override; void visit (nano::message_visitor &) const override; bool deserialize (nano::stream &); @@ -414,7 +416,7 @@ class bulk_pull final : public message { public: using count_t = uint32_t; - bulk_pull (); + explicit bulk_pull (nano::network_constants const & constants); bulk_pull (bool &, nano::stream &, nano::message_header const &); void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -424,14 +426,14 @@ class bulk_pull final : public message count_t count{ 0 }; 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; - static size_t constexpr size = sizeof (start) + sizeof (end); + static std::size_t constexpr count_present_flag = nano::message_header::bulk_pull_count_present_flag; + static std::size_t constexpr extended_parameters_size = 8; + static std::size_t constexpr size = sizeof (start) + sizeof (end); }; class bulk_pull_account final : public message { public: - bulk_pull_account (); + explicit bulk_pull_account (nano::network_constants const & constants); bulk_pull_account (bool &, nano::stream &, nano::message_header const &); void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -439,12 +441,12 @@ class bulk_pull_account final : public message nano::account account; nano::amount minimum_amount; bulk_pull_account_flags flags; - static size_t constexpr size = sizeof (account) + sizeof (minimum_amount) + sizeof (bulk_pull_account_flags); + static std::size_t constexpr size = sizeof (account) + sizeof (minimum_amount) + sizeof (bulk_pull_account_flags); }; class bulk_push final : public message { public: - bulk_push (); + explicit bulk_push (nano::network_constants const & constants); explicit bulk_push (nano::message_header const &); void serialize (nano::stream &) const override; bool deserialize (nano::stream &); @@ -454,15 +456,15 @@ class node_id_handshake final : public message { public: node_id_handshake (bool &, nano::stream &, nano::message_header const &); - node_id_handshake (boost::optional, boost::optional>); + node_id_handshake (nano::network_constants const & constants, boost::optional, boost::optional>); void serialize (nano::stream &) const override; bool deserialize (nano::stream &); void visit (nano::message_visitor &) const override; bool operator== (nano::node_id_handshake const &) const; boost::optional query; boost::optional> response; - size_t size () const; - static size_t size (nano::message_header const &); + std::size_t size () const; + static std::size_t size (nano::message_header const &); }; class message_visitor { diff --git a/nano/node/confirmation_height_bounded.cpp b/nano/node/confirmation_height_bounded.cpp index e6803f14c5..c314a8db78 100644 --- a/nano/node/confirmation_height_bounded.cpp +++ b/nano/node/confirmation_height_bounded.cpp @@ -84,12 +84,12 @@ void nano::confirmation_height_bounded::process (std::shared_ptr or } else { - block = ledger.store.block_get (transaction, current); + block = ledger.store.block.get (transaction, current); } if (!block) { - if (ledger.pruning && ledger.store.pruned_exists (transaction, current)) + if (ledger.pruning && ledger.store.pruned.exists (transaction, current)) { if (!receive_source_pairs.empty ()) { @@ -121,7 +121,7 @@ void nano::confirmation_height_bounded::process (std::shared_ptr or } else { - ledger.store.confirmation_height_get (transaction, account, confirmation_height_info); + ledger.store.confirmation_height.get (transaction, account, confirmation_height_info); // This block was added to the confirmation height processor but is already confirmed if (first_iter && confirmation_height_info.height >= block->sideband ().height && current == original_block->hash ()) { @@ -229,7 +229,7 @@ nano::block_hash nano::confirmation_height_bounded::get_least_unconfirmed_hash_f { if (block_height_a > confirmation_height_info_a.height) { - auto block (ledger.store.block_get (transaction_a, confirmation_height_info_a.frontier)); + auto block (ledger.store.block.get (transaction_a, confirmation_height_info_a.frontier)); release_assert (block != nullptr); least_unconfirmed_hash = block->sideband ().successor; block_height_a = block->sideband ().height + 1; @@ -239,7 +239,7 @@ nano::block_hash nano::confirmation_height_bounded::get_least_unconfirmed_hash_f { // No blocks have been confirmed, so the first block will be the open block nano::account_info account_info; - release_assert (!ledger.store.account_get (transaction_a, account_a, account_info)); + release_assert (!ledger.store.account.get (transaction_a, account_a, account_info)); least_unconfirmed_hash = account_info.open_block; block_height_a = 1; } @@ -257,14 +257,14 @@ bool nano::confirmation_height_bounded::iterate (nano::read_transaction const & // Keep iterating upwards until we either reach the desired block or the second receive. // Once a receive is cemented, we can cement all blocks above it until the next receive, so store those details for later. ++num_blocks; - auto block = ledger.store.block_get (transaction_a, hash); + auto block = ledger.store.block.get (transaction_a, hash); auto source (block->source ()); if (source.is_zero ()) { source = block->link ().as_block_hash (); } - if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.store.block_exists (transaction_a, source)) + if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.store.block.exists (transaction_a, source)) { hit_receive = true; reached_target = true; @@ -308,7 +308,7 @@ void nano::confirmation_height_bounded::prepare_iterated_blocks_for_cementing (p if (!preparation_data_a.already_cemented) { // Add the non-receive blocks iterated for this account - auto block_height = (ledger.store.block_account_height (preparation_data_a.transaction, preparation_data_a.top_most_non_receive_block_hash)); + auto block_height = (ledger.store.block.account_height (preparation_data_a.transaction, preparation_data_a.top_most_non_receive_block_hash)); if (block_height > preparation_data_a.confirmation_height_info.height) { confirmed_info confirmed_info_l{ block_height, preparation_data_a.top_most_non_receive_block_hash }; @@ -378,26 +378,26 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope // of blocks to retain consistent cementing across all account chains to genesis. while (!error && !pending_writes.empty ()) { - const auto & pending = pending_writes.front (); - const auto & account = pending.account; + auto const & pending = pending_writes.front (); + auto const & account = pending.account; auto write_confirmation_height = [&account, &ledger = ledger, &transaction] (uint64_t num_blocks_cemented, uint64_t confirmation_height, nano::block_hash const & confirmed_frontier) { #ifndef NDEBUG // Extra debug checks nano::confirmation_height_info confirmation_height_info; - ledger.store.confirmation_height_get (transaction, account, confirmation_height_info); - auto block (ledger.store.block_get (transaction, confirmed_frontier)); + ledger.store.confirmation_height.get (transaction, account, confirmation_height_info); + auto block (ledger.store.block.get (transaction, confirmed_frontier)); debug_assert (block != nullptr); debug_assert (block->sideband ().height == confirmation_height_info.height + num_blocks_cemented); #endif - ledger.store.confirmation_height_put (transaction, account, nano::confirmation_height_info{ confirmation_height, confirmed_frontier }); + ledger.store.confirmation_height.put (transaction, account, nano::confirmation_height_info{ confirmation_height, confirmed_frontier }); ledger.cache.cemented_count += num_blocks_cemented; ledger.stats.add (nano::stat::type::confirmation_height, nano::stat::detail::blocks_confirmed, nano::stat::dir::in, num_blocks_cemented); ledger.stats.add (nano::stat::type::confirmation_height, nano::stat::detail::blocks_confirmed_bounded, nano::stat::dir::in, num_blocks_cemented); }; nano::confirmation_height_info confirmation_height_info; - ledger.store.confirmation_height_get (transaction, pending.account, confirmation_height_info); + ledger.store.confirmation_height.get (transaction, pending.account, confirmation_height_info); // Some blocks need to be cemented at least if (pending.top_height > confirmation_height_info.height) @@ -416,14 +416,14 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope } else { - auto block = ledger.store.block_get (transaction, confirmation_height_info.frontier); + auto block = ledger.store.block.get (transaction, confirmation_height_info.frontier); new_cemented_frontier = block->sideband ().successor; num_blocks_confirmed = pending.top_height - confirmation_height_info.height; start_height = confirmation_height_info.height + 1; } auto total_blocks_cemented = 0; - auto block = ledger.store.block_get (transaction, new_cemented_frontier); + auto block = ledger.store.block.get (transaction, new_cemented_frontier); // Cementing starts from the bottom of the chain and works upwards. This is because chains can have effectively // an infinite number of send/change blocks in a row. We don't want to hold the write transaction open for too long. @@ -459,18 +459,15 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope } // Update the maximum amount of blocks to write next time based on the time it took to cement this batch. - if (!network_params.network.is_dev_network ()) + if (time_spent_cementing > maximum_batch_write_time) { - if (time_spent_cementing > maximum_batch_write_time) - { - // Reduce (unless we have hit a floor) - batch_write_size = std::max (minimum_batch_write_size, batch_write_size - amount_to_change); - } - else if (time_spent_cementing < maximum_batch_write_time_increase_cutoff) - { - // Increase amount of blocks written for next batch if the time for writing this one is sufficiently lower than the max time to warrant changing - batch_write_size += amount_to_change; - } + // Reduce (unless we have hit a floor) + batch_write_size = std::max (minimum_batch_write_size, batch_write_size - amount_to_change); + } + else if (time_spent_cementing < maximum_batch_write_time_increase_cutoff) + { + // Increase amount of blocks written for next batch if the time for writing this one is sufficiently lower than the max time to warrant changing + batch_write_size += amount_to_change; } scoped_write_guard_a.release (); @@ -490,7 +487,7 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope if (!last_iteration) { new_cemented_frontier = block->sideband ().successor; - block = ledger.store.block_get (transaction, new_cemented_frontier); + block = ledger.store.block.get (transaction, new_cemented_frontier); } else { @@ -538,7 +535,7 @@ void nano::confirmation_height_bounded::cement_blocks (nano::write_guard & scope // Bail if there was an error. This indicates that there was a fatal issue with the ledger // (the blocks probably got rolled back when they shouldn't have). release_assert (!error); - if (!network_params.network.is_dev_network () && time_spent_cementing > maximum_batch_write_time) + if (time_spent_cementing > maximum_batch_write_time) { // Reduce (unless we have hit a floor) batch_write_size = std::max (minimum_batch_write_size, batch_write_size - amount_to_change); diff --git a/nano/node/confirmation_height_bounded.hpp b/nano/node/confirmation_height_bounded.hpp index 85c897977f..ac850600bb 100644 --- a/nano/node/confirmation_height_bounded.hpp +++ b/nano/node/confirmation_height_bounded.hpp @@ -3,7 +3,7 @@ #include #include #include -#include +#include #include @@ -105,7 +105,7 @@ class confirmation_height_bounded final class receive_source_pair final { public: - receive_source_pair (receive_chain_details const &, const nano::block_hash &); + receive_source_pair (receive_chain_details const &, nano::block_hash const &); receive_chain_details receive_details; nano::block_hash source_hash; @@ -128,7 +128,6 @@ class confirmation_height_bounded final std::function> const &)> notify_observers_callback; std::function notify_block_already_cemented_observers_callback; std::function awaiting_processing_size_callback; - nano::network_params network_params; friend std::unique_ptr collect_container_info (confirmation_height_bounded &, std::string const & name_a); }; diff --git a/nano/node/confirmation_height_processor.cpp b/nano/node/confirmation_height_processor.cpp index 8c99a59a22..28e10c53ef 100644 --- a/nano/node/confirmation_height_processor.cpp +++ b/nano/node/confirmation_height_processor.cpp @@ -62,7 +62,7 @@ void nano::confirmation_height_processor::run (confirmation_height_mode mode_a) set_next_hash (); - const auto num_blocks_to_use_unbounded = confirmation_height::unbounded_cutoff; + auto const num_blocks_to_use_unbounded = confirmation_height::unbounded_cutoff; auto blocks_within_automatic_unbounded_selection = (ledger.cache.block_count < num_blocks_to_use_unbounded || ledger.cache.block_count - num_blocks_to_use_unbounded < ledger.cache.cemented_count); // Don't want to mix up pending writes across different processors @@ -128,7 +128,6 @@ void nano::confirmation_height_processor::run (confirmation_height_mode mode_a) else { // Pausing is only utilised in some tests to help prevent it processing added blocks until required. - debug_assert (network_params.network.is_dev_network ()); original_block = nullptr; condition.wait (lk); } @@ -205,8 +204,8 @@ std::unique_ptr nano::collect_container_info (co { auto composite = std::make_unique (name_a); - size_t cemented_observers_count = confirmation_height_processor_a.cemented_observers.size (); - size_t block_already_cemented_observers_count = confirmation_height_processor_a.block_already_cemented_observers.size (); + std::size_t cemented_observers_count = confirmation_height_processor_a.cemented_observers.size (); + std::size_t block_already_cemented_observers_count = confirmation_height_processor_a.block_already_cemented_observers.size (); composite->add_component (std::make_unique (container_info{ "cemented_observers", cemented_observers_count, sizeof (decltype (confirmation_height_processor_a.cemented_observers)::value_type) })); composite->add_component (std::make_unique (container_info{ "block_already_cemented_observers", block_already_cemented_observers_count, sizeof (decltype (confirmation_height_processor_a.block_already_cemented_observers)::value_type) })); composite->add_component (std::make_unique (container_info{ "awaiting_processing", confirmation_height_processor_a.awaiting_processing_size (), sizeof (decltype (confirmation_height_processor_a.awaiting_processing)::value_type) })); @@ -215,7 +214,7 @@ std::unique_ptr nano::collect_container_info (co return composite; } -size_t nano::confirmation_height_processor::awaiting_processing_size () const +std::size_t nano::confirmation_height_processor::awaiting_processing_size () const { nano::lock_guard guard (mutex); return awaiting_processing.size (); diff --git a/nano/node/confirmation_height_processor.hpp b/nano/node/confirmation_height_processor.hpp index 1fbf1d00c8..b5ecedb30a 100644 --- a/nano/node/confirmation_height_processor.hpp +++ b/nano/node/confirmation_height_processor.hpp @@ -4,8 +4,8 @@ #include #include #include -#include #include +#include #include #include @@ -39,7 +39,7 @@ class confirmation_height_processor final void stop (); void add (std::shared_ptr const &); void run (confirmation_height_mode); - size_t awaiting_processing_size () const; + std::size_t awaiting_processing_size () const; bool is_processing_added_block (nano::block_hash const & hash_a) const; bool is_processing_block (nano::block_hash const &) const; nano::block_hash current () const; @@ -91,7 +91,6 @@ class confirmation_height_processor final nano::write_database_queue & write_database_queue; /** The maximum amount of blocks to write at once. This is dynamically modified by the bounded processor based on previous write performance **/ uint64_t batch_write_size{ 16384 }; - nano::network_params network_params; confirmation_height_unbounded unbounded_processor; confirmation_height_bounded bounded_processor; @@ -101,7 +100,7 @@ class confirmation_height_processor final void notify_observers (std::vector> const &); void notify_observers (nano::block_hash const &); - friend std::unique_ptr collect_container_info (confirmation_height_processor &, const std::string &); + friend std::unique_ptr collect_container_info (confirmation_height_processor &, std::string const &); friend class confirmation_height_pending_observer_callbacks_Test; friend class confirmation_height_dependent_election_Test; friend class confirmation_height_dependent_election_after_already_cemented_Test; @@ -113,5 +112,5 @@ class confirmation_height_processor final friend class active_transactions_pessimistic_elections_Test; }; -std::unique_ptr collect_container_info (confirmation_height_processor &, const std::string &); +std::unique_ptr collect_container_info (confirmation_height_processor &, std::string const &); } diff --git a/nano/node/confirmation_height_unbounded.cpp b/nano/node/confirmation_height_unbounded.cpp index 38b835ac02..7f49ff4d0e 100644 --- a/nano/node/confirmation_height_unbounded.cpp +++ b/nano/node/confirmation_height_unbounded.cpp @@ -95,7 +95,7 @@ void nano::confirmation_height_unbounded::process (std::shared_ptr else { nano::confirmation_height_info confirmation_height_info; - ledger.store.confirmation_height_get (read_transaction, account, confirmation_height_info); + ledger.store.confirmation_height.get (read_transaction, account, confirmation_height_info); confirmation_height = confirmation_height_info.height; // This block was added to the confirmation height processor but is already confirmed @@ -222,7 +222,7 @@ void nano::confirmation_height_unbounded::collect_unconfirmed_receive_and_source source = block->link ().as_block_hash (); } - if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.store.block_exists (transaction_a, source)) + if (!source.is_zero () && !ledger.is_epoch_link (source) && ledger.store.block.exists (transaction_a, source)) { if (!hit_receive && !block_callback_data_a.empty ()) { @@ -376,17 +376,17 @@ void nano::confirmation_height_unbounded::cement_blocks (nano::write_guard & sco { auto & pending = pending_writes.front (); nano::confirmation_height_info confirmation_height_info; - ledger.store.confirmation_height_get (transaction, pending.account, confirmation_height_info); + ledger.store.confirmation_height.get (transaction, pending.account, confirmation_height_info); auto confirmation_height = confirmation_height_info.height; if (pending.height > confirmation_height) { - auto block = ledger.store.block_get (transaction, pending.hash); - debug_assert (network_params.network.is_dev_network () || ledger.pruning || block != nullptr); - debug_assert (network_params.network.is_dev_network () || ledger.pruning || block->sideband ().height == pending.height); + auto block = ledger.store.block.get (transaction, pending.hash); + debug_assert (ledger.pruning || block != nullptr); + debug_assert (ledger.pruning || block->sideband ().height == pending.height); if (!block) { - if (ledger.pruning && ledger.store.pruned_exists (transaction, pending.hash)) + if (ledger.pruning && ledger.store.pruned.exists (transaction, pending.hash)) { pending_writes.erase (pending_writes.begin ()); --pending_writes_size; @@ -406,7 +406,7 @@ void nano::confirmation_height_unbounded::cement_blocks (nano::write_guard & sco debug_assert (pending.num_blocks_confirmed == pending.height - confirmation_height); confirmation_height = pending.height; ledger.cache.cemented_count += pending.num_blocks_confirmed; - ledger.store.confirmation_height_put (transaction, pending.account, { confirmation_height, pending.hash }); + ledger.store.confirmation_height.put (transaction, pending.account, { confirmation_height, pending.hash }); // Reverse it so that the callbacks start from the lowest newly cemented block and move upwards std::reverse (pending.block_callback_data.begin (), pending.block_callback_data.end ()); @@ -447,7 +447,7 @@ std::shared_ptr nano::confirmation_height_unbounded::get_block_and_ } else { - auto block (ledger.store.block_get (transaction_a, hash_a)); + auto block (ledger.store.block.get (transaction_a, hash_a)); block_cache.emplace (hash_a, block); return block; } diff --git a/nano/node/confirmation_height_unbounded.hpp b/nano/node/confirmation_height_unbounded.hpp index 2297318730..93199c35d2 100644 --- a/nano/node/confirmation_height_unbounded.hpp +++ b/nano/node/confirmation_height_unbounded.hpp @@ -3,7 +3,7 @@ #include #include #include -#include +#include #include #include @@ -52,7 +52,7 @@ class confirmation_height_unbounded final class receive_source_pair final { public: - receive_source_pair (std::shared_ptr const &, const nano::block_hash &); + receive_source_pair (std::shared_ptr const &, nano::block_hash const &); std::shared_ptr receive_details; nano::block_hash source_hash; @@ -95,7 +95,6 @@ class confirmation_height_unbounded final void collect_unconfirmed_receive_and_sources_for_account (uint64_t, uint64_t, std::shared_ptr const &, nano::block_hash const &, nano::account const &, nano::read_transaction const &, std::vector &, std::vector &, std::vector &, std::shared_ptr original_block); void prepare_iterated_blocks_for_cementing (preparation_data &); - nano::network_params network_params; nano::ledger & ledger; nano::write_database_queue & write_database_queue; std::chrono::milliseconds batch_separate_pending_min_time; diff --git a/nano/node/confirmation_solicitor.cpp b/nano/node/confirmation_solicitor.cpp index 3faf67f725..ee2ba8a7f1 100644 --- a/nano/node/confirmation_solicitor.cpp +++ b/nano/node/confirmation_solicitor.cpp @@ -7,7 +7,7 @@ using namespace std::chrono_literals; nano::confirmation_solicitor::confirmation_solicitor (nano::network & network_a, nano::node_config const & config_a) : max_block_broadcasts (config_a.network_params.network.is_dev_network () ? 4 : 30), max_election_requests (50), - max_election_broadcasts (std::max (network_a.fanout () / 2, 1)), + max_election_broadcasts (std::max (network_a.fanout () / 2, 1)), network (network_a), config (config_a) { @@ -31,7 +31,7 @@ bool nano::confirmation_solicitor::broadcast (nano::election const & election_a) if (rebroadcasted++ < max_block_broadcasts) { auto const & hash (election_a.status.winner->hash ()); - nano::publish winner (election_a.status.winner); + nano::publish winner{ config.network_params.network, election_a.status.winner }; unsigned count = 0; // Directed broadcasting to principal representatives for (auto i (representatives_broadcasts.begin ()), n (representatives_broadcasts.end ()); i != n && count < max_election_broadcasts; ++i) @@ -98,14 +98,14 @@ void nano::confirmation_solicitor::flush () roots_hashes_l.push_back (root_hash); if (roots_hashes_l.size () == nano::network::confirm_req_hashes_max) { - nano::confirm_req req (roots_hashes_l); + nano::confirm_req req{ config.network_params.network, roots_hashes_l }; channel->send (req); roots_hashes_l.clear (); } } if (!roots_hashes_l.empty ()) { - nano::confirm_req req (roots_hashes_l); + nano::confirm_req req{ config.network_params.network, roots_hashes_l }; channel->send (req); } } diff --git a/nano/node/confirmation_solicitor.hpp b/nano/node/confirmation_solicitor.hpp index ed699302f2..066548c231 100644 --- a/nano/node/confirmation_solicitor.hpp +++ b/nano/node/confirmation_solicitor.hpp @@ -24,11 +24,11 @@ class confirmation_solicitor final /** Dispatch bundled requests to each channel*/ void flush (); /** Global maximum amount of block broadcasts */ - size_t const max_block_broadcasts; + std::size_t const max_block_broadcasts; /** Maximum amount of requests to be sent per election, bypassed if an existing vote is for a different hash*/ - size_t const max_election_requests; + std::size_t const max_election_requests; /** Maximum amount of directed broadcasts to be sent per election */ - size_t const max_election_broadcasts; + std::size_t const max_election_broadcasts; private: nano::network & network; diff --git a/nano/node/daemonconfig.cpp b/nano/node/daemonconfig.cpp index 5706dad305..817263f307 100644 --- a/nano/node/daemonconfig.cpp +++ b/nano/node/daemonconfig.cpp @@ -7,8 +7,9 @@ #include #include -nano::daemon_config::daemon_config (boost::filesystem::path const & data_path_a) : - data_path (data_path_a) +nano::daemon_config::daemon_config (boost::filesystem::path const & data_path_a, nano::network_params & network_params) : + node{ network_params }, + data_path{ data_path_a } { } diff --git a/nano/node/daemonconfig.hpp b/nano/node/daemonconfig.hpp index f6cb849c61..42e47220ef 100644 --- a/nano/node/daemonconfig.hpp +++ b/nano/node/daemonconfig.hpp @@ -16,7 +16,7 @@ class daemon_config { public: daemon_config () = default; - daemon_config (boost::filesystem::path const & data_path); + daemon_config (boost::filesystem::path const & data_path, nano::network_params & network_params); nano::error deserialize_json (bool &, nano::jsonconfig &); nano::error serialize_json (nano::jsonconfig &); nano::error deserialize_toml (nano::tomlconfig &); diff --git a/nano/node/distributed_work.cpp b/nano/node/distributed_work.cpp index 540459d66d..a249b71f50 100644 --- a/nano/node/distributed_work.cpp +++ b/nano/node/distributed_work.cpp @@ -154,11 +154,11 @@ void nano::distributed_work::do_request (nano::tcp_endpoint const & endpoint_a) auto peer_request (connection->get_prepared_json_request (request_string)); boost::beast::http::async_write (connection->socket, *peer_request, boost::asio::bind_executor (this_l->strand, - [this_l, connection, peer_request] (boost::system::error_code const & ec, size_t size_a) { + [this_l, connection, peer_request] (boost::system::error_code const & ec, std::size_t size_a) { if (!ec && !this_l->stopped) { boost::beast::http::async_read (connection->socket, connection->buffer, connection->response, - boost::asio::bind_executor (this_l->strand, [this_l, connection] (boost::system::error_code const & ec, size_t size_a) { + boost::asio::bind_executor (this_l->strand, [this_l, connection] (boost::system::error_code const & ec, std::size_t size_a) { if (!ec && !this_l->stopped) { if (connection->response.result () == boost::beast::http::status::ok) @@ -217,7 +217,7 @@ void nano::distributed_work::do_cancel (nano::tcp_endpoint const & endpoint_a) auto peer_cancel (cancelling_l->get_prepared_json_request (request_string)); boost::beast::http::async_write (cancelling_l->socket, *peer_cancel, boost::asio::bind_executor (this_l->strand, - [this_l, peer_cancel, cancelling_l] (boost::system::error_code const & ec, size_t bytes_transferred) { + [this_l, peer_cancel, cancelling_l] (boost::system::error_code const & ec, std::size_t bytes_transferred) { if (ec && ec != boost::system::errc::operation_canceled) { this_l->node.logger.try_log (boost::str (boost::format ("Unable to send work_cancel to work_peer %1% %2%: %3% (%4%)") % cancelling_l->endpoint.address () % cancelling_l->endpoint.port () % ec.message () % ec.value ())); @@ -239,7 +239,7 @@ void nano::distributed_work::success (std::string const & body_a, nano::tcp_endp uint64_t work; if (!nano::from_string_hex (work_text, work)) { - if (nano::work_difficulty (request.version, request.root, work) >= request.difficulty) + if (nano::dev::network_params.work.difficulty (request.version, request.root, work) >= request.difficulty) { error = false; node.unresponsive_work_peers = false; diff --git a/nano/node/distributed_work_factory.cpp b/nano/node/distributed_work_factory.cpp index d7167bc601..6f8666926d 100644 --- a/nano/node/distributed_work_factory.cpp +++ b/nano/node/distributed_work_factory.cpp @@ -88,7 +88,7 @@ void nano::distributed_work_factory::stop () } } -size_t nano::distributed_work_factory::size () const +std::size_t nano::distributed_work_factory::size () const { nano::lock_guard guard_l (mutex); return items.size (); diff --git a/nano/node/distributed_work_factory.hpp b/nano/node/distributed_work_factory.hpp index bd5bcf022a..8de9aa0cce 100644 --- a/nano/node/distributed_work_factory.hpp +++ b/nano/node/distributed_work_factory.hpp @@ -26,7 +26,7 @@ class distributed_work_factory final void cancel (nano::root const &); void cleanup_finished (); void stop (); - size_t size () const; + std::size_t size () const; private: std::unordered_multimap> items; @@ -35,7 +35,7 @@ class distributed_work_factory final mutable nano::mutex mutex; std::atomic stopped{ false }; - friend std::unique_ptr collect_container_info (distributed_work_factory &, const std::string &); + friend std::unique_ptr collect_container_info (distributed_work_factory &, std::string const &); }; std::unique_ptr collect_container_info (distributed_work_factory & distributed_work, std::string const & name); diff --git a/nano/node/election.cpp b/nano/node/election.cpp index e730f15796..0ec923e166 100644 --- a/nano/node/election.cpp +++ b/nano/node/election.cpp @@ -28,7 +28,7 @@ nano::election::election (nano::node & node_a, std::shared_ptr cons root (block_a->root ()), qualified_root (block_a->qualified_root ()) { - last_votes.emplace (node.network_params.random.not_an_account, nano::vote_info{ std::chrono::steady_clock::now (), 0, block_a->hash () }); + last_votes.emplace (nano::account::null (), nano::vote_info{ std::chrono::steady_clock::now (), 0, block_a->hash () }); last_blocks.emplace (block_a->hash (), block_a); if (node.config.enable_voting && node.wallets.reps ().voting > 0) { @@ -193,7 +193,7 @@ bool nano::election::transition_time (nano::confirmation_solicitor & solicitor_a debug_assert (false); break; } - auto const optimistic_expiration_time = node.network_params.network.is_dev_network () ? 500 : 60 * 1000; + auto const optimistic_expiration_time = 60 * 1000; auto const expire_time = std::chrono::milliseconds (optimistic () ? optimistic_expiration_time : 5 * 60 * 1000); if (!confirmed () && expire_time < std::chrono::steady_clock::now () - election_start) { @@ -319,7 +319,7 @@ void nano::election::log_votes (nano::tally_t const & tally_a, std::string const } for (auto i (last_votes.begin ()), n (last_votes.end ()); i != n; ++i) { - if (i->first != node.network_params.random.not_an_account) + if (i->first != nullptr) { tally << boost::str (boost::format ("%1%%2% %3% %4%") % line_end % i->first.to_account () % std::to_string (i->second.timestamp) % i->second.hash.to_string ()); } @@ -437,7 +437,7 @@ bool nano::election::publish (std::shared_ptr const & block_a) return result; } -size_t nano::election::insert_inactive_votes_cache (nano::inactive_cache_information const & cache_a) +std::size_t nano::election::insert_inactive_votes_cache (nano::inactive_cache_information const & cache_a) { nano::unique_lock lock (mutex); for (auto const & [rep, timestamp] : cache_a.voters) @@ -459,7 +459,7 @@ size_t nano::election::insert_inactive_votes_cache (nano::inactive_cache_informa node.stats.add (nano::stat::type::election, nano::stat::detail::late_block_seconds, nano::stat::dir::in, delay.count (), true); } } - if (last_votes.size () > 1) // not_an_account + if (last_votes.size () > 1) // null account { // Even if no votes were in cache, they could be in the election confirm_if_quorum (lock); @@ -629,7 +629,7 @@ std::vector nano::election::votes_with_weight () co auto votes_l (votes ()); for (auto const & vote_l : votes_l) { - if (vote_l.first != node.network_params.random.not_an_account) + if (vote_l.first != nullptr) { auto amount (node.ledger.cache.rep_weights.representation_get (vote_l.first)); nano::vote_with_weight_info vote_info{ vote_l.first, vote_l.second.time, vote_l.second.timestamp, vote_l.second.hash, amount }; diff --git a/nano/node/election.hpp b/nano/node/election.hpp index 234f3700ae..a1358300b7 100644 --- a/nano/node/election.hpp +++ b/nano/node/election.hpp @@ -1,8 +1,8 @@ #pragma once -#include #include #include +#include #include #include @@ -106,7 +106,7 @@ class election final : public std::enable_shared_from_this std::shared_ptr find (nano::block_hash const &) const; nano::election_vote_result vote (nano::account const &, uint64_t, nano::block_hash const &); bool publish (std::shared_ptr const & block_a); - size_t insert_inactive_votes_cache (nano::inactive_cache_information const &); + std::size_t insert_inactive_votes_cache (nano::inactive_cache_information const &); // Confirm this block if quorum is met void confirm_if_quorum (nano::unique_lock &); @@ -142,7 +142,7 @@ class election final : public std::enable_shared_from_this mutable nano::mutex mutex; static std::chrono::seconds constexpr late_blocks_delay{ 5 }; - static size_t constexpr max_blocks{ 10 }; + static std::size_t constexpr max_blocks{ 10 }; friend class active_transactions; friend class confirmation_solicitor; diff --git a/nano/node/election_scheduler.cpp b/nano/node/election_scheduler.cpp index b7fc5f1fac..cd57368de3 100644 --- a/nano/node/election_scheduler.cpp +++ b/nano/node/election_scheduler.cpp @@ -25,15 +25,15 @@ void nano::election_scheduler::activate (nano::account const & account_a, nano:: { debug_assert (!account_a.is_zero ()); nano::account_info account_info; - if (!node.store.account_get (transaction, account_a, account_info)) + if (!node.store.account.get (transaction, account_a, account_info)) { nano::confirmation_height_info conf_info; - node.store.confirmation_height_get (transaction, account_a, conf_info); + node.store.confirmation_height.get (transaction, account_a, conf_info); if (conf_info.height < account_info.block_count) { debug_assert (conf_info.frontier != account_info.head); - auto hash = conf_info.height == 0 ? account_info.open_block : node.store.block_successor (transaction, conf_info.frontier); - auto block = node.store.block_get (transaction, hash); + auto hash = conf_info.height == 0 ? account_info.open_block : node.store.block.successor (transaction, conf_info.frontier); + auto block = node.store.block.get (transaction, hash); debug_assert (block != nullptr); if (node.ledger.dependents_confirmed (transaction, *block)) { @@ -65,7 +65,7 @@ void nano::election_scheduler::notify () condition.notify_all (); } -size_t nano::election_scheduler::size () const +std::size_t nano::election_scheduler::size () const { nano::lock_guard lock{ mutex }; return priority.size () + manual_queue.size (); @@ -82,7 +82,7 @@ bool nano::election_scheduler::empty () const return empty_locked (); } -size_t nano::election_scheduler::priority_queue_size () const +std::size_t nano::election_scheduler::priority_queue_size () const { return priority.size (); } @@ -116,18 +116,22 @@ void nano::election_scheduler::run () { if (overfill_predicate ()) { + lock.unlock (); node.active.erase_oldest (); } else if (manual_queue_predicate ()) { auto const [block, previous_balance, election_behavior, confirmation_action] = manual_queue.front (); + manual_queue.pop_front (); + lock.unlock (); nano::unique_lock lock2 (node.active.mutex); node.active.insert_impl (lock2, block, previous_balance, election_behavior, confirmation_action); - manual_queue.pop_front (); } else if (priority_queue_predicate ()) { auto block = priority.top (); + priority.pop (); + lock.unlock (); std::shared_ptr election; nano::unique_lock lock2 (node.active.mutex); election = node.active.insert_impl (lock2, block).election; @@ -135,9 +139,13 @@ void nano::election_scheduler::run () { election->transition_active (); } - priority.pop (); + } + else + { + lock.unlock (); } notify (); + lock.lock (); } } } diff --git a/nano/node/election_scheduler.hpp b/nano/node/election_scheduler.hpp index 1a2889f2d1..b10fee5415 100644 --- a/nano/node/election_scheduler.hpp +++ b/nano/node/election_scheduler.hpp @@ -29,9 +29,9 @@ class election_scheduler final // Blocks until no more elections can be activated or there are no more elections to activate void flush (); void notify (); - size_t size () const; + std::size_t size () const; bool empty () const; - size_t priority_queue_size () const; + std::size_t priority_queue_size () const; private: void run (); diff --git a/nano/node/gap_cache.cpp b/nano/node/gap_cache.cpp index 6db03b8e42..2b04836b57 100644 --- a/nano/node/gap_cache.cpp +++ b/nano/node/gap_cache.cpp @@ -1,6 +1,6 @@ #include #include -#include +#include #include @@ -121,7 +121,7 @@ nano::uint128_t nano::gap_cache::bootstrap_threshold () return result; } -size_t nano::gap_cache::size () +std::size_t nano::gap_cache::size () { nano::lock_guard lock (mutex); return blocks.size (); diff --git a/nano/node/gap_cache.hpp b/nano/node/gap_cache.hpp index ab26008815..95402f5df3 100644 --- a/nano/node/gap_cache.hpp +++ b/nano/node/gap_cache.hpp @@ -41,7 +41,7 @@ class gap_cache final bool bootstrap_check (std::vector const &, nano::block_hash const &); void bootstrap_start (nano::block_hash const & hash_a); nano::uint128_t bootstrap_threshold (); - size_t size (); + std::size_t size (); // clang-format off class tag_arrival {}; class tag_hash {}; @@ -53,7 +53,7 @@ class gap_cache final boost::multi_index::member>>>; ordered_gaps blocks; // clang-format on - size_t const max = 256; + std::size_t const max = 256; nano::mutex mutex{ mutex_identifier (mutexes::gap_cache) }; nano::node & node; }; diff --git a/nano/node/ipc/action_handler.cpp b/nano/node/ipc/action_handler.cpp index 76086e737c..db191f77b2 100644 --- a/nano/node/ipc/action_handler.cpp +++ b/nano/node/ipc/action_handler.cpp @@ -11,11 +11,12 @@ namespace { nano::account parse_account (std::string const & account, bool & out_is_deprecated_format) { - nano::account result (0); + nano::account result{}; if (account.empty ()) { throw nano::error (nano::error_common::bad_account_number); } + if (result.decode_account (account)) { throw nano::error (nano::error_common::bad_account_number); diff --git a/nano/node/ipc/flatbuffers_handler.cpp b/nano/node/ipc/flatbuffers_handler.cpp index ca91f527a9..a5bd7d902e 100644 --- a/nano/node/ipc/flatbuffers_handler.cpp +++ b/nano/node/ipc/flatbuffers_handler.cpp @@ -35,25 +35,15 @@ std::string make_error_response (std::string const & error_message) /** * Returns the 'api/flatbuffers' directory, boost::none if not found. - * This searches the binary path as well as the parent (which is mostly useful for development) */ boost::optional get_api_path () { - auto parent_path = boost::dll::program_location ().parent_path (); - if (!boost::filesystem::exists (parent_path / "api" / "flatbuffers")) + boost::filesystem::path const fb_path = "api/flatbuffers"; + if (!boost::filesystem::exists (fb_path)) { - // See if the parent directory has the api subdirectories - if (parent_path.has_parent_path ()) - { - parent_path = boost::dll::program_location ().parent_path ().parent_path (); - } - - if (!boost::filesystem::exists (parent_path / "api" / "flatbuffers")) - { - return boost::none; - } + return boost::none; } - return parent_path / "api" / "flatbuffers"; + return fb_path; } } @@ -77,7 +67,7 @@ std::shared_ptr nano::ipc::flatbuffers_handler::make_flatbu throw nano::error ("Internal IPC error: unable to find api path"); } - const char * include_directories[] = { api_path->string ().c_str (), nullptr }; + char const * include_directories[] = { api_path->string ().c_str (), nullptr }; std::string schemafile; if (!flatbuffers::LoadFile ((*api_path / "nanoapi.fbs").string ().c_str (), false, &schemafile)) { @@ -94,7 +84,7 @@ std::shared_ptr nano::ipc::flatbuffers_handler::make_flatbu return parser; } -void nano::ipc::flatbuffers_handler::process_json (const uint8_t * message_buffer_a, size_t buffer_size_a, +void nano::ipc::flatbuffers_handler::process_json (uint8_t const * message_buffer_a, std::size_t buffer_size_a, std::function const &)> const & response_handler) { try @@ -107,7 +97,7 @@ std::function const &)> const & response_hand // Convert request from JSON auto body (std::string (reinterpret_cast (const_cast (message_buffer_a)), buffer_size_a)); body += '\0'; - if (parser->Parse (reinterpret_cast (body.data ()))) + if (parser->Parse (reinterpret_cast (body.data ()))) { process (parser->builder_.GetBufferPointer (), parser->builder_.GetSize (), [parser = parser, response_handler] (std::shared_ptr const & fbb) { // Convert response to JSON @@ -144,7 +134,7 @@ std::function const &)> const & response_hand } } -void nano::ipc::flatbuffers_handler::process (const uint8_t * message_buffer_a, size_t buffer_size_a, +void nano::ipc::flatbuffers_handler::process (uint8_t const * message_buffer_a, std::size_t buffer_size_a, std::function const &)> const & response_handler) { auto buffer_l (std::make_shared ()); diff --git a/nano/node/ipc/flatbuffers_handler.hpp b/nano/node/ipc/flatbuffers_handler.hpp index ac588e3191..8437d6e952 100644 --- a/nano/node/ipc/flatbuffers_handler.hpp +++ b/nano/node/ipc/flatbuffers_handler.hpp @@ -42,12 +42,12 @@ namespace ipc * @param response_handler Receives a shared pointer to the flatbuffer builder, from which the buffer and size can be queried * @throw Throws std:runtime_error on deserialization or processing errors */ - void process (const uint8_t * message_buffer_a, size_t buffer_size_a, std::function const &)> const & response_handler); + void process (uint8_t const * message_buffer_a, std::size_t buffer_size_a, std::function const &)> const & response_handler); /** * Parses a JSON encoded requests into Flatbuffer format, calls process(), yields the result as a JSON string */ - void process_json (const uint8_t * message_buffer_a, size_t buffer_size_a, std::function const &)> const & response_handler); + void process_json (uint8_t const * message_buffer_a, std::size_t buffer_size_a, std::function const &)> const & response_handler); /** * Creates a Flatbuffers parser with the schema preparsed. This can then be used to parse and produce JSON. diff --git a/nano/node/ipc/flatbuffers_util.cpp b/nano/node/ipc/flatbuffers_util.cpp index 20813943d3..8cf1fe5e40 100644 --- a/nano/node/ipc/flatbuffers_util.cpp +++ b/nano/node/ipc/flatbuffers_util.cpp @@ -3,9 +3,8 @@ #include #include -std::unique_ptr nano::ipc::flatbuffers_builder::from (nano::state_block const & block_a, nano::amount const & amount_a, bool is_state_send_a) +std::unique_ptr nano::ipc::flatbuffers_builder::from (nano::state_block const & block_a, nano::amount const & amount_a, bool is_state_send_a, bool is_state_epoch_a) { - static nano::network_params params; auto block (std::make_unique ()); block->account = block_a.account ().to_account (); block->hash = block_a.hash ().to_string (); @@ -25,7 +24,7 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nano { block->subtype = nanoapi::BlockSubType::BlockSubType_change; } - else if (amount_a == 0 && params.ledger.epochs.is_epoch_link (block_a.link ())) + else if (amount_a == 0 && is_state_epoch_a) { block->subtype = nanoapi::BlockSubType::BlockSubType_epoch; } @@ -82,14 +81,14 @@ std::unique_ptr nano::ipc::flatbuffers_builder::from (nan return block; } -nanoapi::BlockUnion nano::ipc::flatbuffers_builder::block_to_union (nano::block const & block_a, nano::amount const & amount_a, bool is_state_send_a) +nanoapi::BlockUnion nano::ipc::flatbuffers_builder::block_to_union (nano::block const & block_a, nano::amount const & amount_a, bool is_state_send_a, bool is_state_epoch_a) { nanoapi::BlockUnion u; switch (block_a.type ()) { case nano::block_type::state: { - u.Set (*from (dynamic_cast (block_a), amount_a, is_state_send_a)); + u.Set (*from (dynamic_cast (block_a), amount_a, is_state_send_a, is_state_epoch_a)); break; } case nano::block_type::send: diff --git a/nano/node/ipc/flatbuffers_util.hpp b/nano/node/ipc/flatbuffers_util.hpp index c1236a9413..2e7f8fcf1a 100644 --- a/nano/node/ipc/flatbuffers_util.hpp +++ b/nano/node/ipc/flatbuffers_util.hpp @@ -21,8 +21,8 @@ namespace ipc class flatbuffers_builder { public: - static nanoapi::BlockUnion block_to_union (nano::block const & block_a, nano::amount const & amount_a, bool is_state_send_a = false); - static std::unique_ptr from (nano::state_block const & block_a, nano::amount const & amount_a, bool is_state_send_a); + static nanoapi::BlockUnion block_to_union (nano::block const & block_a, nano::amount const & amount_a, bool is_state_send_a = false, bool is_state_epoch_a = false); + static std::unique_ptr from (nano::state_block const & block_a, nano::amount const & amount_a, bool is_state_send_a, bool is_state_epoch_a); static std::unique_ptr from (nano::send_block const & block_a); static std::unique_ptr from (nano::receive_block const & block_a); static std::unique_ptr from (nano::open_block const & block_a); diff --git a/nano/node/ipc/ipc_broker.cpp b/nano/node/ipc/ipc_broker.cpp index b3af919fdc..5176b3b131 100644 --- a/nano/node/ipc/ipc_broker.cpp +++ b/nano/node/ipc/ipc_broker.cpp @@ -22,7 +22,7 @@ std::shared_ptr nano::ipc::subscriber::get_parser (nano::ip void nano::ipc::broker::start () { - node.observers.blocks.add ([this_l = shared_from_this ()] (nano::election_status const & status_a, std::vector const & votes_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a) { + node.observers.blocks.add ([this_l = shared_from_this ()] (nano::election_status const & status_a, std::vector const & votes_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a, bool is_state_epoch_a) { debug_assert (status_a.type != nano::election_status_type::ongoing); try @@ -51,7 +51,7 @@ void nano::ipc::broker::start () break; }; confirmation->confirmation_type = nanoapi::TopicConfirmationType::TopicConfirmationType_active_quorum; - confirmation->block = nano::ipc::flatbuffers_builder::block_to_union (*status_a.winner, amount_a, is_state_send_a); + confirmation->block = nano::ipc::flatbuffers_builder::block_to_union (*status_a.winner, amount_a, is_state_send_a, is_state_epoch_a); confirmation->election_info = std::make_unique (); confirmation->election_info->duration = status_a.election_duration.count (); confirmation->election_info->time = status_a.election_end.count (); @@ -144,7 +144,8 @@ void nano::ipc::broker::broadcast (std::shared_ptr if (itr->topic->options->all_local_accounts) { auto transaction_l (this->node.wallets.tx_begin_read ()); - nano::account source_l (0), destination_l (0); + nano::account source_l{}; + nano::account destination_l{}; auto decode_source_ok_l (!source_l.decode_account (state->account)); auto decode_destination_ok_l (!destination_l.decode_account (state->link_as_account)); (void)decode_source_ok_l; @@ -194,11 +195,11 @@ void nano::ipc::broker::broadcast (std::shared_ptr throw nano::error ("Couldn't serialize response to JSON"); } - subscriber_l->async_send_message (reinterpret_cast (json->data ()), json->size (), [json] (const nano::error & err) {}); + subscriber_l->async_send_message (reinterpret_cast (json->data ()), json->size (), [json] (nano::error const & err) {}); } else { - subscriber_l->async_send_message (fb->GetBufferPointer (), fb->GetSize (), [fb] (const nano::error & err) {}); + subscriber_l->async_send_message (fb->GetBufferPointer (), fb->GetSize (), [fb] (nano::error const & err) {}); } } @@ -221,7 +222,7 @@ void nano::ipc::broker::broadcast (std::shared_ptr } } -size_t nano::ipc::broker::confirmation_subscriber_count () const +std::size_t nano::ipc::broker::confirmation_subscriber_count () const { return confirmation_subscribers->size (); } @@ -245,7 +246,7 @@ void nano::ipc::broker::service_stop (std::string const & service_name_a) { nanoapi::EventServiceStopT event_stop; auto fb (nano::ipc::flatbuffer_producer::make_buffer (event_stop)); - subscriber_l->async_send_message (fb->GetBufferPointer (), fb->GetSize (), [fb] (const nano::error & err) {}); + subscriber_l->async_send_message (fb->GetBufferPointer (), fb->GetSize (), [fb] (nano::error const & err) {}); break; } diff --git a/nano/node/ipc/ipc_broker.hpp b/nano/node/ipc/ipc_broker.hpp index df3d1eb04c..5f56023bee 100644 --- a/nano/node/ipc/ipc_broker.hpp +++ b/nano/node/ipc/ipc_broker.hpp @@ -35,7 +35,7 @@ namespace ipc * @param length_a Length of payload message in bytes * @param broadcast_completion_handler_a Called once sending is completed */ - virtual void async_send_message (uint8_t const * data_a, size_t length_a, std::function broadcast_completion_handler_a) = 0; + virtual void async_send_message (uint8_t const * data_a, std::size_t length_a, std::function broadcast_completion_handler_a) = 0; /** Returns the unique id of the associated session */ virtual uint64_t get_id () const = 0; /** Returns the service name associated with the session */ @@ -86,7 +86,7 @@ namespace ipc void subscribe (std::weak_ptr const & subscriber_a, std::shared_ptr const & service_stop_a); /** Returns the number of confirmation subscribers */ - size_t confirmation_subscriber_count () const; + std::size_t confirmation_subscriber_count () const; /** Associate the service name with the subscriber */ void service_register (std::string const & service_name_a, std::weak_ptr const & subscriber_a); /** Sends a notification to the session associated with the given service (if the session has subscribed to TopicServiceStop) */ diff --git a/nano/node/ipc/ipc_config.cpp b/nano/node/ipc/ipc_config.cpp index eeffcd6961..f3d229294a 100644 --- a/nano/node/ipc/ipc_config.cpp +++ b/nano/node/ipc/ipc_config.cpp @@ -43,7 +43,7 @@ nano::error nano::ipc::ipc_config::deserialize_toml (nano::tomlconfig & toml) tcp_l->get ("allow_unsafe", transport_tcp.allow_unsafe); tcp_l->get ("enable", transport_tcp.enabled); tcp_l->get ("port", transport_tcp.port); - tcp_l->get ("io_timeout", transport_tcp.io_timeout); + tcp_l->get ("io_timeout", transport_tcp.io_timeout); } auto domain_l (toml.get_optional_child ("local")); @@ -53,7 +53,7 @@ nano::error nano::ipc::ipc_config::deserialize_toml (nano::tomlconfig & toml) domain_l->get ("allow_unsafe", transport_domain.allow_unsafe); domain_l->get ("enable", transport_domain.enabled); domain_l->get ("path", transport_domain.path); - domain_l->get ("io_timeout", transport_domain.io_timeout); + domain_l->get ("io_timeout", transport_domain.io_timeout); } auto flatbuffers_l (toml.get_optional_child ("flatbuffers")); @@ -102,7 +102,7 @@ nano::error nano::ipc::ipc_config::deserialize_json (bool & upgraded_a, nano::js tcp_l->get_optional ("allow_unsafe", transport_tcp.allow_unsafe); tcp_l->get ("enable", transport_tcp.enabled); tcp_l->get ("port", transport_tcp.port); - tcp_l->get ("io_timeout", transport_tcp.io_timeout); + tcp_l->get ("io_timeout", transport_tcp.io_timeout); } auto domain_l (json.get_optional_child ("local")); @@ -112,7 +112,7 @@ nano::error nano::ipc::ipc_config::deserialize_json (bool & upgraded_a, nano::js domain_l->get_optional ("allow_unsafe", transport_domain.allow_unsafe); domain_l->get ("enable", transport_domain.enabled); domain_l->get ("path", transport_domain.path); - domain_l->get ("io_timeout", transport_domain.io_timeout); + domain_l->get ("io_timeout", transport_domain.io_timeout); } return json.get_error (); diff --git a/nano/node/ipc/ipc_config.hpp b/nano/node/ipc/ipc_config.hpp index ad7d4b4ee4..d675d757ce 100644 --- a/nano/node/ipc/ipc_config.hpp +++ b/nano/node/ipc/ipc_config.hpp @@ -18,7 +18,7 @@ namespace ipc virtual ~ipc_config_transport () = default; bool enabled{ false }; bool allow_unsafe{ false }; - size_t io_timeout{ 15 }; + std::size_t io_timeout{ 15 }; long io_threads{ -1 }; }; @@ -52,11 +52,12 @@ namespace ipc class ipc_config_tcp_socket : public ipc_config_transport { public: - ipc_config_tcp_socket () : - port (network_constants.default_ipc_port) + ipc_config_tcp_socket (nano::network_constants & network_constants) : + network_constants{ network_constants }, + port{ network_constants.default_ipc_port } { } - nano::network_constants network_constants; + nano::network_constants & network_constants; /** Listening port */ uint16_t port; }; @@ -65,6 +66,10 @@ namespace ipc class ipc_config { public: + ipc_config (nano::network_constants & network_constants) : + transport_tcp{ network_constants } + { + } nano::error deserialize_json (bool & upgraded_a, nano::jsonconfig & json_a); nano::error serialize_json (nano::jsonconfig & json) const; nano::error deserialize_toml (nano::tomlconfig & toml_a); diff --git a/nano/node/ipc/ipc_server.cpp b/nano/node/ipc/ipc_server.cpp index b6544aae73..3cb98ce74d 100644 --- a/nano/node/ipc/ipc_server.cpp +++ b/nano/node/ipc/ipc_server.cpp @@ -66,7 +66,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f session_m (session_a) { } - virtual void async_send_message (uint8_t const * data_a, size_t length_a, std::function broadcast_completion_handler_a) override + virtual void async_send_message (uint8_t const * data_a, std::size_t length_a, std::function broadcast_completion_handler_a) override { if (auto session_l = session_m.lock ()) { @@ -76,7 +76,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f boost::asio::buffer (data_a, length_a) }; - session_l->queued_write (buffers, [broadcast_completion_handler_a, big_endian_length] (boost::system::error_code const & ec_a, size_t size_a) { + session_l->queued_write (buffers, [broadcast_completion_handler_a, big_endian_length] (boost::system::error_code const & ec_a, std::size_t size_a) { if (broadcast_completion_handler_a) { nano::error error_l (ec_a); @@ -140,7 +140,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f /** Write a fixed array of buffers through the queue. Once the last item is completed, the callback is invoked */ template - void queued_write (boost::array & buffers, std::function callback_a) + void queued_write (boost::array & buffers, std::function callback_a) { auto this_l (this->shared_from_this ()); boost::asio::post (strand, boost::asio::bind_executor (strand, [buffers, callback_a, this_l] () { @@ -148,7 +148,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f auto queue_size = this_l->send_queue.size (); if (queue_size < this_l->queue_size_max) { - for (size_t i = 0; i < N - 1; i++) + for (std::size_t i = 0; i < N - 1; i++) { this_l->send_queue.emplace_back (queue_item{ buffers[i], nullptr }); } @@ -167,7 +167,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f * @note This function explicitely doesn't use nano::shared_const_buffer, as buffers usually originate from Flatbuffers * and copying into the shared_const_buffer vector would impose a significant overhead for large requests and responses. */ - void queued_write (boost::asio::const_buffer const & buffer_a, std::function callback_a) + void queued_write (boost::asio::const_buffer const & buffer_a, std::function callback_a) { auto this_l (this->shared_from_this ()); boost::asio::post (strand, boost::asio::bind_executor (strand, [buffer_a, callback_a, this_l] () { @@ -215,16 +215,16 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f * no error has occurred. On error, the error is logged, the read cycle stops and the session ends. Clients * are expected to implement reconnect logic. */ - void async_read_exactly (void * buff_a, size_t size_a, std::function const & callback_a) + void async_read_exactly (void * buff_a, std::size_t size_a, std::function const & callback_a) { async_read_exactly (buff_a, size_a, std::chrono::seconds (config_transport.io_timeout), callback_a); } /** * Async read of exactly \p size_a bytes and a specific \p timeout_a. - * @see async_read_exactly (void *, size_t, std::function) + * @see async_read_exactly (void *, std::size_t, std::function) */ - void async_read_exactly (void * buff_a, size_t size_a, std::chrono::seconds timeout_a, std::function const & callback_a) + void async_read_exactly (void * buff_a, std::size_t size_a, std::chrono::seconds timeout_a, std::function const & callback_a) { timer_start (timeout_a); auto this_l (this->shared_from_this ()); @@ -232,7 +232,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f boost::asio::buffer (buff_a, size_a), boost::asio::transfer_exactly (size_a), boost::asio::bind_executor (strand, - [this_l, callback_a] (boost::system::error_code const & ec, size_t bytes_transferred_a) { + [this_l, callback_a] (boost::system::error_code const & ec, std::size_t bytes_transferred_a) { this_l->timer_cancel (); if (ec == boost::asio::error::broken_pipe || ec == boost::asio::error::connection_aborted || ec == boost::asio::error::connection_reset || ec == boost::asio::error::connection_refused) { @@ -268,7 +268,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f } this_l->timer_start (std::chrono::seconds (this_l->config_transport.io_timeout)); - this_l->queued_write (boost::asio::buffer (buffer->data (), buffer->size ()), [this_l, buffer] (boost::system::error_code const & error_a, size_t size_a) { + this_l->queued_write (boost::asio::buffer (buffer->data (), buffer->size ()), [this_l, buffer] (boost::system::error_code const & error_a, std::size_t size_a) { this_l->timer_cancel (); if (!error_a) { @@ -357,7 +357,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f boost::asio::buffer (body->data (), body->size ()) }; - this_l->queued_write (buffers, [this_l, body, big_endian_length] (boost::system::error_code const & error_a, size_t size_a) { + this_l->queued_write (buffers, [this_l, body, big_endian_length] (boost::system::error_code const & error_a, std::size_t size_a) { if (!error_a) { this_l->read_next_request (); @@ -383,7 +383,7 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f boost::asio::buffer (fbb->GetBufferPointer (), fbb->GetSize ()) }; - this_l->queued_write (buffers, [this_l, fbb, big_endian_length] (boost::system::error_code const & error_a, size_t size_a) { + this_l->queued_write (buffers, [this_l, fbb, big_endian_length] (boost::system::error_code const & error_a, std::size_t size_a) { if (!error_a) { this_l->read_next_request (); @@ -419,9 +419,9 @@ class session final : public nano::ipc::socket_base, public std::enable_shared_f { public: boost::asio::const_buffer buffer; - std::function callback; + std::function callback; }; - size_t const queue_size_max = 64 * 1024; + std::size_t const queue_size_max = 64 * 1024; nano::ipc::ipc_server & server; nano::node & node; @@ -561,7 +561,7 @@ class socket_transport : public nano::ipc::transport */ void await_hup_signal (std::shared_ptr const & signals, nano::ipc::ipc_server & server_a) { - signals->async_wait ([signals, &server_a] (const boost::system::error_code & ec, int signal_number) { + signals->async_wait ([signals, &server_a] (boost::system::error_code const & ec, int signal_number) { if (ec != boost::asio::error::operation_aborted) { std::cout << "Reloading access configuration..." << std::endl; diff --git a/nano/node/json_handler.cpp b/nano/node/json_handler.cpp index 65c8fbcb7d..1be6aed9fd 100644 --- a/nano/node/json_handler.cpp +++ b/nano/node/json_handler.cpp @@ -1,4 +1,5 @@ #include +#include #include #include #include @@ -22,7 +23,7 @@ using ipc_json_handler_no_arg_func_map = std::unordered_map const & response_a, std::function stop_callback_a) : @@ -60,7 +61,7 @@ void nano::json_handler::process_request (bool unsafe_a) boost::property_tree::read_json (istream, request); if (node_rpc_config.request_callback) { - debug_assert (nano::network_constants ().is_dev_network ()); + debug_assert (node.network_params.network.is_dev_network ()); node_rpc_config.request_callback (request); } action = request.get ("action"); @@ -94,6 +95,7 @@ void nano::json_handler::process_request (bool unsafe_a) } else if (action == "history") { + response_l.put ("deprecated", "1"); request.put ("head", request.get ("hash")); account_history (); } @@ -105,11 +107,11 @@ void nano::json_handler::process_request (bool unsafe_a) { mnano_to_raw (nano::banoshi_ratio); } - else if (action == "nano_from_raw" || action == "raw_from_raw") + else if (action == "raw_from_raw") { mnano_from_raw (nano::RAW_ratio); } - else if (action == "nano_to_raw" || action == "raw_to_raw") + else if (action == "raw_to_raw") { mnano_to_raw (nano::RAW_ratio); } @@ -121,6 +123,26 @@ void nano::json_handler::process_request (bool unsafe_a) { mnano_to_raw (); } + else if (action == "nano_to_raw") + { + nano_to_raw (); + } + else if (action == "raw_to_nano") + { + raw_to_nano (); + } + else if (action == "raw_to_dec") + { + raw_to_dec (); + } + else if (action == "representatives_decimal_millions") + { + representatives_decimal_millions (); + } + else if (action == "delegators_decimal") + { + delegators_decimal (); + } else if (action == "password_valid") { password_valid (); @@ -226,7 +248,7 @@ bool nano::json_handler::wallet_account_impl (nano::transaction const & transact nano::account nano::json_handler::account_impl (std::string account_text, std::error_code ec_a) { - nano::account result (0); + nano::account result{}; if (!ec) { if (account_text.empty ()) @@ -251,7 +273,7 @@ nano::account_info nano::json_handler::account_info_impl (nano::transaction cons nano::account_info result; if (!ec) { - if (node.store.account_get (transaction_a, account_a, result)) + if (node.store.account.get (transaction_a, account_a, result)) { ec = nano::error_common::account_not_found; node.bootstrap_initiator.bootstrap_lazy (account_a, false, false, account_a.to_account ()); @@ -276,7 +298,7 @@ nano::amount nano::json_handler::amount_impl () std::shared_ptr nano::json_handler::block_impl (bool signature_work_required) { - const bool json_block_l = request.get ("json_block", false); + bool const json_block_l = request.get ("json_block", false); std::shared_ptr result{ nullptr }; if (!ec) { @@ -381,12 +403,12 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a) auto previous (block_a.previous ()); if (!previous.is_zero ()) { - block_previous = node.store.block_get (transaction, previous); + block_previous = node.store.block.get (transaction, previous); } // Send check if (block_previous != nullptr) { - details.is_send = node.store.block_balance (transaction, previous) > block_a.balance ().number (); + details.is_send = node.store.block.balance (transaction, previous) > block_a.balance ().number (); details_found = true; } // Epoch check @@ -397,15 +419,15 @@ uint64_t nano::json_handler::difficulty_ledger (nano::block const & block_a) auto link (block_a.link ()); if (!link.is_zero () && !details.is_send) { - auto block_link (node.store.block_get (transaction, link.as_block_hash ())); - if (block_link != nullptr && node.store.pending_exists (transaction, nano::pending_key (block_a.account (), link.as_block_hash ()))) + auto block_link (node.store.block.get (transaction, link.as_block_hash ())); + if (block_link != nullptr && node.store.pending.exists (transaction, nano::pending_key (block_a.account (), link.as_block_hash ()))) { details.epoch = std::max (details.epoch, block_link->sideband ().details.epoch); details.is_receive = true; details_found = true; } } - return details_found ? nano::work_threshold (block_a.work_version (), details) : node.default_difficulty (block_a.work_version ()); + return details_found ? node.network_params.work.threshold (block_a.work_version (), details) : node.default_difficulty (block_a.work_version ()); } double nano::json_handler::multiplier_optional_impl (nano::work_version const version_a, uint64_t & difficulty) @@ -450,7 +472,7 @@ namespace bool decode_unsigned (std::string const & text, uint64_t & number) { bool result; - size_t end; + std::size_t end; try { number = std::stoull (text, &end); @@ -514,10 +536,14 @@ void nano::json_handler::account_balance () auto account (account_impl ()); if (!ec) { - const bool include_only_confirmed = request.get ("include_only_confirmed", true); + bool const include_only_confirmed = request.get ("include_only_confirmed", true); auto balance (node.balance_pending (account, include_only_confirmed)); response_l.put ("balance", balance.first.convert_to ()); + response_l.put ("balance_decimal", convert_raw_to_dec (balance.first.convert_to ())); response_l.put ("pending", balance.second.convert_to ()); + response_l.put ("pending_decimal", convert_raw_to_dec (balance.second.convert_to ())); + response_l.put ("receivable", balance.second.convert_to ()); + response_l.put ("receivable_decimal", convert_raw_to_dec (balance.second.convert_to ())); } response_errors (); } @@ -543,7 +569,7 @@ void nano::json_handler::account_create () auto wallet (rpc_l->wallet_impl ()); if (!rpc_l->ec) { - const bool generate_work = rpc_l->request.get ("work", true); + bool const generate_work = rpc_l->request.get ("work", true); nano::account new_key; auto index_text (rpc_l->request.get_optional ("index")); if (index_text.is_initialized ()) @@ -599,14 +625,14 @@ void nano::json_handler::account_info () auto account (account_impl ()); if (!ec) { - const bool representative = request.get ("representative", false); - const bool weight = request.get ("weight", false); - const bool pending = request.get ("pending", false); - const bool include_confirmed = request.get ("include_confirmed", false); + bool const representative = request.get ("representative", false); + bool const weight = request.get ("weight", false); + bool const pending = request.get ("pending", false); + bool const include_confirmed = request.get ("include_confirmed", false); auto transaction (node.store.tx_begin_read ()); auto info (account_info_impl (transaction, account)); nano::confirmation_height_info confirmation_height_info; - node.store.confirmation_height_get (transaction, account, confirmation_height_info); + node.store.confirmation_height.get (transaction, account, confirmation_height_info); if (!ec) { response_l.put ("frontier", info.head.to_string ()); @@ -617,6 +643,7 @@ void nano::json_handler::account_info () balance_l.encode_dec (balance); response_l.put ("balance", balance); + response_l.put ("balance_decimal", convert_raw_to_dec (balance)); nano::amount confirmed_balance_l; if (include_confirmed) @@ -633,6 +660,7 @@ void nano::json_handler::account_info () std::string confirmed_balance; confirmed_balance_l.encode_dec (confirmed_balance); response_l.put ("confirmed_balance", confirmed_balance); + response_l.put ("confirmed_balance", convert_raw_to_dec (confirmed_balance)); } response_l.put ("modified_timestamp", std::to_string (info.modified)); @@ -654,7 +682,7 @@ void nano::json_handler::account_info () std::shared_ptr confirmed_frontier_block; if (include_confirmed && confirmation_height_info.height > 0) { - confirmed_frontier_block = node.store.block_get (transaction, confirmed_frontier); + confirmed_frontier_block = node.store.block.get (transaction, confirmation_height_info.frontier); } if (representative) @@ -662,13 +690,13 @@ void nano::json_handler::account_info () response_l.put ("representative", info.representative.to_account ()); if (include_confirmed) { - nano::account confirmed_representative{ 0 }; + nano::account confirmed_representative{}; if (confirmed_frontier_block) { confirmed_representative = confirmed_frontier_block->representative (); if (confirmed_representative.is_zero ()) { - confirmed_representative = node.store.block_get (transaction, node.ledger.representative (transaction, confirmed_frontier))->representative (); + confirmed_representative = node.store.block.get (transaction, node.ledger.representative (transaction, confirmation_height_info.frontier))->representative (); } } @@ -679,16 +707,22 @@ void nano::json_handler::account_info () { auto account_weight (node.ledger.weight (account)); response_l.put ("weight", account_weight.convert_to ()); + response_l.put ("weight_decimal", convert_raw_to_dec (account_weight.convert_to ())); + response_l.put ("weight_decimal_millions", convert_raw_to_dec (account_weight.convert_to (), nano::MBAN_ratio)); } if (pending) { auto account_pending (node.ledger.account_pending (transaction, account)); response_l.put ("pending", account_pending.convert_to ()); + response_l.put ("pending_decimal", convert_raw_to_dec (account_pending.convert_to ())); + response_l.put ("receivable", account_pending.convert_to ()); + response_l.put ("receivable_decimal", convert_raw_to_dec (account_pending.convert_to ())); if (include_confirmed) { auto account_pending (node.ledger.account_pending (transaction, account, true)); response_l.put ("confirmed_pending", account_pending.convert_to ()); + response_l.put ("confirmed_pending_decimal", convert_raw_to_dec (account_pending.convert_to ())); } } } @@ -820,7 +854,7 @@ void nano::json_handler::account_representative_set () if (!rpc_l->ec) { nano::block_details details (info.epoch (), false, false, false); - if (nano::work_difficulty (nano::work_version::work_1, info.head, work) < nano::work_threshold (nano::work_version::work_1, details)) + if (rpc_l->node.network_params.work.difficulty (nano::work_version::work_1, info.head, work) < rpc_l->node.network_params.work.threshold (nano::work_version::work_1, details)) { rpc_l->ec = nano::error_common::invalid_work; } @@ -871,6 +905,7 @@ void nano::json_handler::account_weight () { auto balance (node.weight (account)); response_l.put ("weight", balance.convert_to ()); + response_l.put ("weight_decimal", convert_raw_to_dec (balance.convert_to ())); } response_errors (); } @@ -886,7 +921,11 @@ void nano::json_handler::accounts_balances () boost::property_tree::ptree entry; auto balance (node.balance_pending (account, false)); entry.put ("balance", balance.first.convert_to ()); + entry.put ("balance_decimal", convert_raw_to_dec (balance.first.convert_to ())); entry.put ("pending", balance.second.convert_to ()); + entry.put ("balance_decimal", convert_raw_to_dec (balance.first.convert_to ())); + entry.put ("receivable", balance.second.convert_to ()); + entry.put ("receivable_decimal", convert_raw_to_dec (balance.first.convert_to ())); balances.push_back (std::make_pair (account.to_account (), entry)); } } @@ -894,6 +933,26 @@ void nano::json_handler::accounts_balances () response_errors (); } +void nano::json_handler::accounts_representatives () +{ + boost::property_tree::ptree representatives; + for (auto & accounts : request.get_child ("accounts")) + { + auto account (account_impl (accounts.second.data ())); + auto transaction (node.store.tx_begin_read ()); + auto info (account_info_impl (transaction, account)); + + if (!ec) + { + boost::property_tree::ptree entry; + entry.put ("", info.representative.to_account ()); + representatives.push_back (std::make_pair (accounts.second.data (), entry)); + } + } + response_l.add_child ("representatives", representatives); + response_errors (); +} + void nano::json_handler::accounts_create () { node.workers.push_task (create_worker_task ([] (std::shared_ptr const & rpc_l) { @@ -901,7 +960,7 @@ void nano::json_handler::accounts_create () auto count (rpc_l->count_impl ()); if (!rpc_l->ec) { - const bool generate_work = rpc_l->request.get ("work", false); + bool const generate_work = rpc_l->request.get ("work", false); boost::property_tree::ptree accounts; for (auto i (0); accounts.size () < count; ++i) { @@ -943,10 +1002,10 @@ void nano::json_handler::accounts_pending () { auto count (count_optional_impl ()); auto threshold (threshold_optional_impl ()); - const bool source = request.get ("source", false); - const bool include_active = request.get ("include_active", false); - const bool include_only_confirmed = request.get ("include_only_confirmed", true); - const bool sorting = request.get ("sorting", false); + bool const source = request.get ("source", false); + bool const include_active = request.get ("include_active", false); + bool const include_only_confirmed = request.get ("include_only_confirmed", true); + bool const sorting = request.get ("sorting", false); auto simple (threshold.is_zero () && !source && !sorting); // if simple, response is a list of hashes for each account boost::property_tree::ptree pending; auto transaction (node.store.tx_begin_read ()); @@ -956,7 +1015,7 @@ void nano::json_handler::accounts_pending () if (!ec) { boost::property_tree::ptree peers_l; - for (auto i (node.store.pending_begin (transaction, nano::pending_key (account, 0))), n (node.store.pending_end ()); i != n && nano::pending_key (i->first).account == account && peers_l.size () < count; ++i) + for (auto i (node.store.pending.begin (transaction, nano::pending_key (account, 0))), n (node.store.pending.end ()); i != n && nano::pending_key (i->first).account == account && peers_l.size () < count; ++i) { nano::pending_key const & key (i->first); if (block_confirmed (node, transaction, key.hash, include_active, include_only_confirmed)) @@ -976,6 +1035,7 @@ void nano::json_handler::accounts_pending () { boost::property_tree::ptree pending_tree; pending_tree.put ("amount", info.amount.number ().convert_to ()); + pending_tree.put ("amount_decimal", convert_raw_to_dec (info.amount.number ().convert_to ())); pending_tree.put ("source", info.source.to_account ()); peers_l.add_child (key.hash.to_string (), pending_tree); } @@ -991,18 +1051,21 @@ void nano::json_handler::accounts_pending () { if (source) { - peers_l.sort ([] (const auto & child1, const auto & child2) -> bool { + peers_l.sort ([] (auto const & child1, auto const & child2) -> bool { return child1.second.template get ("amount") > child2.second.template get ("amount"); }); } else { - peers_l.sort ([] (const auto & child1, const auto & child2) -> bool { + peers_l.sort ([] (auto const & child1, auto const & child2) -> bool { return child1.second.template get ("") > child2.second.template get (""); }); } } - pending.add_child (account.to_account (), peers_l); + if (!peers_l.empty ()) + { + pending.add_child (account.to_account (), peers_l); + } } } response_l.add_child ("blocks", pending); @@ -1015,7 +1078,7 @@ void nano::json_handler::active_difficulty () auto const multiplier_active = 1.0; auto const default_difficulty (node.default_difficulty (nano::work_version::work_1)); auto const default_receive_difficulty (node.default_receive_difficulty (nano::work_version::work_1)); - auto const receive_current_denormalized (nano::denormalized_multiplier (multiplier_active, node.network_params.network.publish_thresholds.epoch_2_receive)); + auto const receive_current_denormalized (node.network_params.work.denormalized_multiplier (multiplier_active, node.network_params.work.epoch_2_receive)); response_l.put ("deprecated", "1"); response_l.put ("network_minimum", nano::to_string_hex (default_difficulty)); response_l.put ("network_receive_minimum", nano::to_string_hex (default_receive_difficulty)); @@ -1024,19 +1087,25 @@ void nano::json_handler::active_difficulty () response_l.put ("multiplier", 1.0); if (include_trend) { - boost::property_tree::ptree trend_entry_l; - response_l.add_child ("difficulty_trend", trend_entry_l); + boost::property_tree::ptree difficulty_trend_l; + + // To keep this RPC backwards-compatible + boost::property_tree::ptree entry; + entry.put ("", "1.000000000000000"); + difficulty_trend_l.push_back (std::make_pair ("", entry)); + + response_l.add_child ("difficulty_trend", difficulty_trend_l); } response_errors (); } void nano::json_handler::available_supply () { - auto genesis_balance (node.balance (node.network_params.ledger.genesis_account)); // Cold storage genesis + auto genesis_balance (node.balance (node.network_params.ledger.genesis->account ())); // Cold storage genesis auto landing_balance (node.balance (nano::account ("059F68AAB29DE0D3A27443625C7EA9CDDB6517A8B76FE37727EF6A4D76832AD5"))); // Active unavailable account auto faucet_balance (node.balance (nano::account ("8E319CE6F3025E5B2DF66DA7AB1467FE48F1679C13DD43BFDB29FA2E9FC40D3B"))); // Faucet account - auto burned_balance ((node.balance_pending (nano::account (0), false)).second); // Burning 0 account - auto available (node.network_params.ledger.genesis_amount - genesis_balance - landing_balance - faucet_balance - burned_balance); + auto burned_balance ((node.balance_pending (nano::account{}, false)).second); // Burning 0 account + auto available (nano::dev::constants.genesis_amount - genesis_balance - landing_balance - faucet_balance - burned_balance); response_l.put ("available", available.convert_to ()); response_errors (); } @@ -1047,7 +1116,7 @@ void nano::json_handler::block_info () if (!ec) { auto transaction (node.store.tx_begin_read ()); - auto block (node.store.block_get (transaction, hash)); + auto block (node.store.block.get (transaction, hash)); if (block != nullptr) { nano::account account (block->account ().is_zero () ? block->sideband ().account : block->account ()); @@ -1057,11 +1126,14 @@ void nano::json_handler::block_info () if (!error_or_pruned) { response_l.put ("amount", amount.convert_to ()); + response_l.put ("amount_decimal", convert_raw_to_dec (amount.convert_to ())); } auto balance (node.ledger.balance (transaction, hash)); response_l.put ("balance", balance.convert_to ()); + response_l.put ("balance_decimal", convert_raw_to_dec (balance.convert_to ())); response_l.put ("height", std::to_string (block->sideband ().height)); response_l.put ("local_timestamp", std::to_string (block->sideband ().timestamp)); + response_l.put ("successor", block->sideband ().successor.to_string ()); auto confirmed (node.ledger.block_confirmed (transaction, hash)); response_l.put ("confirmed", confirmed); @@ -1098,7 +1170,7 @@ void nano::json_handler::block_confirm () if (!ec) { auto transaction (node.store.tx_begin_read ()); - auto block_l (node.store.block_get (transaction, hash)); + auto block_l (node.store.block.get (transaction, hash)); if (block_l != nullptr) { if (!node.ledger.block_confirmed (transaction, hash)) @@ -1120,14 +1192,16 @@ void nano::json_handler::block_confirm () bool error_or_pruned (false); auto amount (node.ledger.amount_safe (transaction, hash, error_or_pruned)); bool is_state_send (false); + bool is_state_epoch (false); if (!error_or_pruned) { if (auto state = dynamic_cast (block_l.get ())) { is_state_send = node.ledger.is_send (transaction, *state); + is_state_epoch = amount == 0 && node.ledger.is_epoch_link (state->link ()); } } - node.observers.blocks.notify (status, {}, account, amount, is_state_send); + node.observers.blocks.notify (status, {}, account, amount, is_state_send, is_state_epoch); } response_l.put ("started", "1"); } @@ -1141,7 +1215,7 @@ void nano::json_handler::block_confirm () void nano::json_handler::blocks () { - const bool json_block_l = request.get ("json_block", false); + bool const json_block_l = request.get ("json_block", false); boost::property_tree::ptree blocks; auto transaction (node.store.tx_begin_read ()); for (boost::property_tree::ptree::value_type & hashes : request.get_child ("hashes")) @@ -1152,7 +1226,7 @@ void nano::json_handler::blocks () nano::block_hash hash; if (!hash.decode_hex (hash_text)) { - auto block (node.store.block_get (transaction, hash)); + auto block (node.store.block.get (transaction, hash)); if (block != nullptr) { if (json_block_l) @@ -1185,10 +1259,10 @@ void nano::json_handler::blocks () void nano::json_handler::blocks_info () { - const bool pending = request.get ("pending", false); - const bool source = request.get ("source", false); - const bool json_block_l = request.get ("json_block", false); - const bool include_not_found = request.get ("include_not_found", false); + bool const pending = request.get ("pending", false); + bool const source = request.get ("source", false); + bool const json_block_l = request.get ("json_block", false); + bool const include_not_found = request.get ("include_not_found", false); boost::property_tree::ptree blocks; boost::property_tree::ptree blocks_not_found; @@ -1201,7 +1275,7 @@ void nano::json_handler::blocks_info () nano::block_hash hash; if (!hash.decode_hex (hash_text)) { - auto block (node.store.block_get (transaction, hash)); + auto block (node.store.block.get (transaction, hash)); if (block != nullptr) { boost::property_tree::ptree entry; @@ -1212,11 +1286,14 @@ void nano::json_handler::blocks_info () if (!error_or_pruned) { entry.put ("amount", amount.convert_to ()); + entry.put ("amount_decimal", convert_raw_to_dec (amount.convert_to ())); } auto balance (node.ledger.balance (transaction, hash)); entry.put ("balance", balance.convert_to ()); + entry.put ("balance_decimal", convert_raw_to_dec (balance.convert_to ())); entry.put ("height", std::to_string (block->sideband ().height)); entry.put ("local_timestamp", std::to_string (block->sideband ().timestamp)); + entry.put ("successor", block->sideband ().successor.to_string ()); auto confirmed (node.ledger.block_confirmed (transaction, hash)); entry.put ("confirmed", confirmed); @@ -1243,14 +1320,14 @@ void nano::json_handler::blocks_info () auto destination (node.ledger.block_destination (transaction, *block)); if (!destination.is_zero ()) { - exists = node.store.pending_exists (transaction, nano::pending_key (destination, hash)); + exists = node.store.pending.exists (transaction, nano::pending_key (destination, hash)); } entry.put ("pending", exists ? "1" : "0"); } if (source) { nano::block_hash source_hash (node.ledger.block_source (transaction, *block)); - auto block_a (node.store.block_get (transaction, source_hash)); + auto block_a (node.store.block.get (transaction, source_hash)); if (block_a != nullptr) { auto source_account (node.ledger.account (transaction, source_hash)); @@ -1297,7 +1374,7 @@ void nano::json_handler::block_account () if (!ec) { auto transaction (node.store.tx_begin_read ()); - if (node.store.block_exists (transaction, hash)) + if (node.store.block.exists (transaction, hash)) { auto account (node.ledger.account (transaction, hash)); response_l.put ("account", account.to_account ()); @@ -1313,7 +1390,7 @@ void nano::json_handler::block_account () void nano::json_handler::block_count () { response_l.put ("count", std::to_string (node.ledger.cache.block_count)); - response_l.put ("unchecked", std::to_string (node.store.unchecked_count (node.store.tx_begin_read ()))); + response_l.put ("unchecked", std::to_string (node.store.unchecked.count (node.store.tx_begin_read ()))); response_l.put ("cemented", std::to_string (node.ledger.cache.cemented_count)); if (node.flags.enable_pruning) { @@ -1338,19 +1415,19 @@ void nano::json_handler::block_create () ec = nano::error_common::bad_wallet_number; } } - nano::account account (0); + nano::account account{}; boost::optional account_text (request.get_optional ("account")); if (!ec && account_text.is_initialized ()) { account = account_impl (account_text.get ()); } - nano::account representative (0); + nano::account representative{}; boost::optional representative_text (request.get_optional ("representative")); if (!ec && representative_text.is_initialized ()) { representative = account_impl (representative_text.get (), nano::error_rpc::bad_representative_number); } - nano::account destination (0); + nano::account destination{}; boost::optional destination_text (request.get_optional ("destination")); if (!ec && destination_text.is_initialized ()) { @@ -1459,7 +1536,7 @@ void nano::json_handler::block_create () auto block_response_put_l = [rpc_l, this] (nano::block const & block_a) { boost::property_tree::ptree response_l; response_l.put ("hash", block_a.hash ().to_string ()); - response_l.put ("difficulty", nano::to_string_hex (block_a.difficulty ())); + response_l.put ("difficulty", nano::to_string_hex (rpc_l->node.network_params.work.difficulty (block_a))); bool json_block_l = request.get ("json_block", false); if (json_block_l) { @@ -1517,7 +1594,7 @@ void nano::json_handler::block_create () else if (previous_text.is_initialized () && balance_text.is_initialized () && type == "send") { auto transaction (node.store.tx_begin_read ()); - if (node.store.block_exists (transaction, previous) && node.store.block_balance (transaction, previous) != balance.number ()) + if (node.store.block.exists (transaction, previous) && node.store.block.balance (transaction, previous) != balance.number ()) { ec = nano::error_rpc::block_create_balance_mismatch; } @@ -1714,10 +1791,10 @@ void nano::json_handler::bootstrap () void nano::json_handler::bootstrap_any () { - const bool force = request.get ("force", false); + bool const force = request.get ("force", false); if (!node.flags.disable_legacy_bootstrap) { - nano::account start_account (0); + nano::account start_account{}; boost::optional account_text (request.get_optional ("account")); if (account_text.is_initialized ()) { @@ -1737,7 +1814,7 @@ void nano::json_handler::bootstrap_any () void nano::json_handler::bootstrap_lazy () { auto hash (hash_impl ()); - const bool force = request.get ("force", false); + bool const force = request.get ("force", false); if (!ec) { if (!node.flags.disable_lazy_bootstrap) @@ -1810,7 +1887,7 @@ void nano::json_handler::chain (bool successors) auto transaction (node.store.tx_begin_read ()); while (!hash.is_zero () && blocks.size () < count) { - auto block_l (node.store.block_get (transaction, hash)); + auto block_l (node.store.block.get (transaction, hash)); if (block_l != nullptr) { if (offset > 0) @@ -1823,7 +1900,7 @@ void nano::json_handler::chain (bool successors) entry.put ("", hash.to_string ()); blocks.push_back (std::make_pair ("", entry)); } - hash = successors ? node.store.block_successor (transaction, hash) : block_l->previous (); + hash = successors ? node.store.block.successor (transaction, hash) : block_l->previous (); } else { @@ -1904,6 +1981,7 @@ void nano::json_handler::confirmation_history () election.put ("duration", status.election_duration.count ()); election.put ("time", status.election_end.count ()); election.put ("tally", status.tally.to_string_dec ()); + election.put ("tally_decimal", convert_raw_to_dec (status.tally.to_string_dec ())); election.add ("final", status.final_tally.to_string_dec ()); election.put ("blocks", std::to_string (status.block_count)); election.put ("voters", std::to_string (status.voter_count)); @@ -1925,9 +2003,9 @@ void nano::json_handler::confirmation_history () void nano::json_handler::confirmation_info () { - const bool representatives = request.get ("representatives", false); - const bool contents = request.get ("contents", true); - const bool json_block_l = request.get ("json_block", false); + bool const representatives = request.get ("representatives", false); + bool const contents = request.get ("contents", true); + bool const json_block_l = request.get ("json_block", false); std::string root_text (request.get ("root")); nano::qualified_root root; if (!root.decode_hex (root_text)) @@ -1945,6 +2023,7 @@ void nano::json_handler::confirmation_info () { boost::property_tree::ptree entry; entry.put ("tally", tally.convert_to ()); + entry.put ("tally_decimal", convert_raw_to_dec (tally.convert_to ())); total += tally; if (contents) { @@ -1982,7 +2061,9 @@ void nano::json_handler::confirmation_info () blocks.add_child ((block->hash ()).to_string (), entry); } response_l.put ("total_tally", total.convert_to ()); + response_l.put ("total_tally_decimal", convert_raw_to_dec (total.convert_to ())); response_l.put ("final_tally", info.status.final_tally.to_string_dec ()); + //response_l.put ("final_tally_decimal", info.status.final_tally.to_string_dec ()); response_l.add_child ("blocks", blocks); } else @@ -2000,11 +2081,16 @@ void nano::json_handler::confirmation_info () void nano::json_handler::confirmation_quorum () { response_l.put ("quorum_delta", node.online_reps.delta ().convert_to ()); + response_l.put ("quorum_delta_decimal", convert_raw_to_dec (node.online_reps.delta ().convert_to ())); response_l.put ("online_weight_quorum_percent", std::to_string (node.online_reps.online_weight_quorum)); response_l.put ("online_weight_minimum", node.config.online_weight_minimum.to_string_dec ()); + response_l.put ("online_weight_minimum_decimal", convert_raw_to_dec (node.config.online_weight_minimum.to_string_dec ())); response_l.put ("online_stake_total", node.online_reps.online ().convert_to ()); + response_l.put ("online_stake_total_decimal", convert_raw_to_dec (node.online_reps.online ().convert_to ())); response_l.put ("trended_stake_total", node.online_reps.trended ().convert_to ()); + response_l.put ("trended_stake_total_decimal", convert_raw_to_dec (node.online_reps.trended ().convert_to ())); response_l.put ("peers_stake_total", node.rep_crawler.total_weight ().convert_to ()); + response_l.put ("peers_stake_total_decimal", convert_raw_to_dec (node.rep_crawler.total_weight ().convert_to ())); if (request.get ("peer_details", false)) { boost::property_tree::ptree peers; @@ -2014,6 +2100,7 @@ void nano::json_handler::confirmation_quorum () peer_node.put ("account", peer.account.to_account ()); peer_node.put ("ip", peer.channel->to_string ()); peer_node.put ("weight", peer.weight.to_string_dec ()); + peer_node.put ("weight_decimal", convert_raw_to_dec (peer.weight.to_string_dec ())); peers.push_back (std::make_pair ("", peer_node)); } response_l.add_child ("peers", peers); @@ -2068,20 +2155,69 @@ void nano::json_handler::database_txn_tracker () void nano::json_handler::delegators () { - auto account (account_impl ()); + auto representative (account_impl ()); + auto count (count_optional_impl (1024)); + auto threshold (threshold_optional_impl ()); + auto start_account_text (request.get_optional ("start")); + + nano::account start_account{}; + if (!ec && start_account_text.is_initialized ()) + { + start_account = account_impl (start_account_text.get ()); + } + if (!ec) { + auto transaction (node.store.tx_begin_read ()); boost::property_tree::ptree delegators; + for (auto i (node.store.account.begin (transaction, start_account.number () + 1)), n (node.store.account.end ()); i != n && delegators.size () < count; ++i) + { + nano::account_info const & info (i->second); + if (info.representative == representative) + { + if (info.balance.number () >= threshold.number ()) + { + std::string balance; + nano::uint128_union (info.balance).encode_dec (balance); + nano::account const & delegator (i->first); + delegators.put (delegator.to_account (), balance); + } + } + } + response_l.add_child ("delegators", delegators); + } + response_errors (); +} + +void nano::json_handler::delegators_decimal () +{ + auto representative (account_impl ()); + auto count (count_optional_impl (1024)); + auto threshold (threshold_optional_impl ()); + auto start_account_text (request.get_optional ("start")); + + nano::account start_account{}; + if (!ec && start_account_text.is_initialized ()) + { + start_account = account_impl (start_account_text.get ()); + } + + if (!ec) + { auto transaction (node.store.tx_begin_read ()); - for (auto i (node.store.accounts_begin (transaction)), n (node.store.accounts_end ()); i != n; ++i) + boost::property_tree::ptree delegators; + for (auto i (node.store.account.begin (transaction, start_account.number () + 1)), n (node.store.account.end ()); i != n && delegators.size () < count; ++i) { nano::account_info const & info (i->second); - if (info.representative == account) + if (info.representative == representative) { - std::string balance; - nano::uint128_union (info.balance).encode_dec (balance); - nano::account const & account (i->first); - delegators.put (account.to_account (), balance); + if (info.balance.number () >= threshold.number ()) + { + std::string balance; + nano::uint128_union (info.balance).encode_dec (balance); + nano::account const & delegator (i->first); + delegators.put (delegator.to_account (), convert_raw_to_dec (balance)); + } } } response_l.add_child ("delegators", delegators); @@ -2096,7 +2232,7 @@ void nano::json_handler::delegators_count () { uint64_t count (0); auto transaction (node.store.tx_begin_read ()); - for (auto i (node.store.accounts_begin (transaction)), n (node.store.accounts_end ()); i != n; ++i) + for (auto i (node.store.account.begin (transaction)), n (node.store.account.end ()); i != n; ++i) { nano::account_info const & info (i->second); if (info.representative == account) @@ -2207,7 +2343,7 @@ void nano::json_handler::frontiers () { boost::property_tree::ptree frontiers; auto transaction (node.store.tx_begin_read ()); - for (auto i (node.store.accounts_begin (transaction, start)), n (node.store.accounts_end ()); i != n && frontiers.size () < count; ++i) + for (auto i (node.store.account.begin (transaction, start)), n (node.store.account.end ()); i != n && frontiers.size () < count; ++i) { frontiers.put (i->first.to_account (), i->second.head.to_string ()); } @@ -2252,11 +2388,13 @@ class history_visitor : public nano::block_visitor if (!error_or_pruned) { tree.put ("amount", amount); + tree.put ("amount_decimal", convert_raw_to_dec (amount)); } if (raw) { tree.put ("destination", account); tree.put ("balance", block_a.hashables.balance.to_string_dec ()); + tree.put ("balance_decimal", convert_raw_to_dec (block_a.hashables.balance.to_string_dec ())); tree.put ("previous", block_a.hashables.previous.to_string ()); } } @@ -2273,6 +2411,7 @@ class history_visitor : public nano::block_visitor tree.put ("account", source_account.to_account ()); } tree.put ("amount", amount); + tree.put ("amount_decimal", convert_raw_to_dec (amount)); } if (raw) { @@ -2294,7 +2433,7 @@ class history_visitor : public nano::block_visitor // Report opens as a receive tree.put ("type", "receive"); } - if (block_a.hashables.source != network_params.ledger.genesis_account) + if (block_a.hashables.source != handler.node.ledger.constants.genesis->account ()) { bool error_or_pruned (false); auto amount (handler.node.ledger.amount_safe (transaction, hash, error_or_pruned).convert_to ()); @@ -2306,12 +2445,14 @@ class history_visitor : public nano::block_visitor tree.put ("account", source_account.to_account ()); } tree.put ("amount", amount); + tree.put ("amount_decimal", convert_raw_to_dec (amount)); } } else { - tree.put ("account", network_params.ledger.genesis_account.to_account ()); - tree.put ("amount", network_params.ledger.genesis_amount.convert_to ()); + tree.put ("account", handler.node.ledger.constants.genesis->account ().to_account ()); + tree.put ("amount", nano::dev::constants.genesis_amount.convert_to ()); + tree.put ("amount_decimal", convert_raw_to_dec (nano::dev::constants.genesis_amount.convert_to ())); } } void change_block (nano::change_block const & block_a) @@ -2331,6 +2472,7 @@ class history_visitor : public nano::block_visitor tree.put ("representative", block_a.hashables.representative.to_account ()); tree.put ("link", block_a.hashables.link.to_string ()); tree.put ("balance", block_a.hashables.balance.to_string_dec ()); + tree.put ("balance_decimal", convert_raw_to_dec (block_a.hashables.balance.to_string_dec ())); tree.put ("previous", block_a.hashables.previous.to_string ()); } auto balance (block_a.hashables.balance.number ()); @@ -2364,6 +2506,7 @@ class history_visitor : public nano::block_visitor } tree.put ("account", block_a.hashables.link.to_account ()); tree.put ("amount", (previous_balance - balance).convert_to ()); + tree.put ("amount_decimal", convert_raw_to_dec ((previous_balance - balance).convert_to ())); } else { @@ -2403,6 +2546,7 @@ class history_visitor : public nano::block_visitor tree.put ("account", source_account.to_account ()); } tree.put ("amount", (balance - previous_balance).convert_to ()); + tree.put ("amount_decimal", convert_raw_to_dec ((balance - previous_balance).convert_to ())); } } } @@ -2423,7 +2567,6 @@ class history_visitor : public nano::block_visitor nano::transaction & transaction; boost::property_tree::ptree & tree; nano::block_hash const & hash; - nano::network_params network_params; std::vector const & accounts_filter; }; } @@ -2431,7 +2574,7 @@ class history_visitor : public nano::block_visitor void nano::json_handler::account_history () { std::vector accounts_to_filter; - const auto accounts_filter_node = request.get_child_optional ("account_filter"); + auto const accounts_filter_node = request.get_child_optional ("account_filter"); if (accounts_filter_node.is_initialized ()) { for (auto & a : (*accounts_filter_node)) @@ -2458,7 +2601,7 @@ void nano::json_handler::account_history () { if (!hash.decode_hex (*head_str)) { - if (node.store.block_exists (transaction, hash)) + if (node.store.block.exists (transaction, hash)) { account = node.ledger.account (transaction, hash); } @@ -2496,7 +2639,7 @@ void nano::json_handler::account_history () boost::property_tree::ptree history; bool output_raw (request.get_optional ("raw") == true); response_l.put ("account", account.to_account ()); - auto block (node.store.block_get (transaction, hash)); + auto block (node.store.block.get (transaction, hash)); while (block != nullptr && count > 0) { if (offset > 0) @@ -2513,6 +2656,7 @@ void nano::json_handler::account_history () entry.put ("local_timestamp", std::to_string (block->sideband ().timestamp)); entry.put ("height", std::to_string (block->sideband ().height)); entry.put ("hash", hash.to_string ()); + entry.put ("confirmed", node.ledger.block_confirmed (transaction, hash)); if (output_raw) { entry.put ("work", nano::to_string_hex (block->block_work ())); @@ -2522,8 +2666,8 @@ void nano::json_handler::account_history () --count; } } - hash = reverse ? node.store.block_successor (transaction, hash) : block->previous (); - block = node.store.block_get (transaction, hash); + hash = reverse ? node.store.block.successor (transaction, hash) : block->previous (); + block = node.store.block.get (transaction, hash); } response_l.add_child ("history", history); if (!hash.is_zero ()) @@ -2587,7 +2731,7 @@ void nano::json_handler::ledger () auto threshold (threshold_optional_impl ()); if (!ec) { - nano::account start (0); + nano::account start{}; boost::optional account_text (request.get_optional ("account")); if (account_text.is_initialized ()) { @@ -2602,15 +2746,15 @@ void nano::json_handler::ledger () ec = nano::error_rpc::invalid_timestamp; } } - const bool sorting = request.get ("sorting", false); - const bool representative = request.get ("representative", false); - const bool weight = request.get ("weight", false); - const bool pending = request.get ("pending", false); + bool const sorting = request.get ("sorting", false); + bool const representative = request.get ("representative", false); + bool const weight = request.get ("weight", false); + bool const pending = request.get ("pending", false); boost::property_tree::ptree accounts; auto transaction (node.store.tx_begin_read ()); if (!ec && !sorting) // Simple { - for (auto i (node.store.accounts_begin (transaction, start)), n (node.store.accounts_end ()); i != n && accounts.size () < count; ++i) + for (auto i (node.store.account.begin (transaction, start)), n (node.store.account.end ()); i != n && accounts.size () < count; ++i) { nano::account_info const & info (i->second); if (info.modified >= modified_since && (pending || info.balance.number () >= threshold.number ())) @@ -2625,6 +2769,9 @@ void nano::json_handler::ledger () continue; } response_a.put ("pending", account_pending.convert_to ()); + response_a.put ("pending_decimal", convert_raw_to_dec (account_pending.convert_to ())); + response_a.put ("receivable", account_pending.convert_to ()); + response_a.put ("receivable_decimal", convert_raw_to_dec (account_pending.convert_to ())); } response_a.put ("frontier", info.head.to_string ()); response_a.put ("open_block", info.open_block.to_string ()); @@ -2632,6 +2779,7 @@ void nano::json_handler::ledger () std::string balance; nano::uint128_union (info.balance).encode_dec (balance); response_a.put ("balance", balance); + response_a.put ("balance_decimal", convert_raw_to_dec (balance)); response_a.put ("modified_timestamp", std::to_string (info.modified)); response_a.put ("block_count", std::to_string (info.block_count)); if (representative) @@ -2642,6 +2790,7 @@ void nano::json_handler::ledger () { auto account_weight (node.ledger.weight (account)); response_a.put ("weight", account_weight.convert_to ()); + response_a.put ("weight_decimal", convert_raw_to_dec (account_weight.convert_to ())); } accounts.push_back (std::make_pair (account.to_account (), response_a)); } @@ -2650,7 +2799,7 @@ void nano::json_handler::ledger () else if (!ec) // Sorting { std::vector> ledger_l; - for (auto i (node.store.accounts_begin (transaction, start)), n (node.store.accounts_end ()); i != n; ++i) + for (auto i (node.store.account.begin (transaction, start)), n (node.store.account.end ()); i != n; ++i) { nano::account_info const & info (i->second); nano::uint128_union balance (info.balance); @@ -2664,7 +2813,7 @@ void nano::json_handler::ledger () nano::account_info info; for (auto i (ledger_l.begin ()), n (ledger_l.end ()); i != n && accounts.size () < count; ++i) { - node.store.account_get (transaction, i->second, info); + node.store.account.get (transaction, i->second, info); if (pending || info.balance.number () >= threshold.number ()) { nano::account const & account (i->second); @@ -2677,6 +2826,9 @@ void nano::json_handler::ledger () continue; } response_a.put ("pending", account_pending.convert_to ()); + response_a.put ("pending_decimal", convert_raw_to_dec (account_pending.convert_to ())); + response_a.put ("receivable", account_pending.convert_to ()); + response_a.put ("receivable_decimal", convert_raw_to_dec (account_pending.convert_to ())); } response_a.put ("frontier", info.head.to_string ()); response_a.put ("open_block", info.open_block.to_string ()); @@ -2684,6 +2836,7 @@ void nano::json_handler::ledger () std::string balance; (i->first).encode_dec (balance); response_a.put ("balance", balance); + response_a.put ("balance_decimal", convert_raw_to_dec (balance)); response_a.put ("modified_timestamp", std::to_string (info.modified)); response_a.put ("block_count", std::to_string (info.block_count)); if (representative) @@ -2694,6 +2847,7 @@ void nano::json_handler::ledger () { auto account_weight (node.ledger.weight (account)); response_a.put ("weight", account_weight.convert_to ()); + response_a.put ("weight_decimal", convert_raw_to_dec (account_weight.convert_to ())); } accounts.push_back (std::make_pair (account.to_account (), response_a)); } @@ -2707,6 +2861,7 @@ void nano::json_handler::ledger () void nano::json_handler::mnano_from_raw (nano::uint128_t ratio) { auto amount (amount_impl ()); + response_l.put ("deprecated", "1"); if (!ec) { auto result (amount.number () / ratio); @@ -2718,6 +2873,7 @@ void nano::json_handler::mnano_from_raw (nano::uint128_t ratio) void nano::json_handler::mnano_to_raw (nano::uint128_t ratio) { auto amount (amount_impl ()); + response_l.put ("deprecated", "1"); if (!ec) { auto result (amount.number () * ratio); @@ -2733,6 +2889,45 @@ void nano::json_handler::mnano_to_raw (nano::uint128_t ratio) response_errors (); } +void nano::json_handler::nano_to_raw () +{ + auto amount (amount_impl ()); + if (!ec) + { + auto result (amount.number () * nano::MBAN_ratio); + if (result > amount.number ()) + { + response_l.put ("amount", result.convert_to ()); + } + else + { + ec = nano::error_common::invalid_amount_big; + } + } + response_errors (); +} + +void nano::json_handler::raw_to_dec () +{ + auto amount (amount_impl ()); + if (!ec) + { + response_l.put ("amount_decimal", convert_raw_to_dec (amount.number ().convert_to ())); + } + response_errors (); +} + +void nano::json_handler::raw_to_nano () +{ + auto amount (amount_impl ()); + if (!ec) + { + auto result (amount.number () / nano::MBAN_ratio); + response_l.put ("amount", result.convert_to ()); + } + response_errors (); +} + /* * @warning This is an internal/diagnostic RPC, do not rely on its interface being stable */ @@ -2817,9 +3012,9 @@ void nano::json_handler::password_valid (bool wallet_locked) void nano::json_handler::peers () { boost::property_tree::ptree peers_l; - const bool peer_details = request.get ("peer_details", false); - auto peers_list (node.network.list (std::numeric_limits::max ())); - std::sort (peers_list.begin (), peers_list.end (), [] (const auto & lhs, const auto & rhs) { + bool const peer_details = request.get ("peer_details", false); + auto peers_list (node.network.list (std::numeric_limits::max ())); + std::sort (peers_list.begin (), peers_list.end (), [] (auto const & lhs, auto const & rhs) { return lhs->get_endpoint () < rhs->get_endpoint (); }); for (auto i (peers_list.begin ()), n (peers_list.end ()); i != n; ++i) @@ -2857,13 +3052,13 @@ void nano::json_handler::pending () auto account (account_impl ()); auto count (count_optional_impl ()); auto threshold (threshold_optional_impl ()); - const bool source = request.get ("source", false); - const bool min_version = request.get ("min_version", false); - const bool include_active = request.get ("include_active", false); - const bool include_only_confirmed = request.get ("include_only_confirmed", true); - const bool sorting = request.get ("sorting", false); + bool const source = request.get ("source", false); + bool const min_version = request.get ("min_version", false); + bool const include_active = request.get ("include_active", false); + bool const include_only_confirmed = request.get ("include_only_confirmed", true); + bool const sorting = request.get ("sorting", false); auto simple (threshold.is_zero () && !source && !min_version && !sorting); // if simple, response is a list of hashes - const bool should_sort = sorting && !simple; + bool const should_sort = sorting && !simple; if (!ec) { boost::property_tree::ptree peers_l; @@ -2871,7 +3066,7 @@ void nano::json_handler::pending () // The ptree container is used if there are any children nodes (e.g source/min_version) otherwise the amount container is used. std::vector> hash_ptree_pairs; std::vector> hash_amount_pairs; - for (auto i (node.store.pending_begin (transaction, nano::pending_key (account, 0))), n (node.store.pending_end ()); i != n && nano::pending_key (i->first).account == account && (should_sort || peers_l.size () < count); ++i) + for (auto i (node.store.pending.begin (transaction, nano::pending_key (account, 0))), n (node.store.pending.end ()); i != n && nano::pending_key (i->first).account == account && (should_sort || peers_l.size () < count); ++i) { nano::pending_key const & key (i->first); if (block_confirmed (node, transaction, key.hash, include_active, include_only_confirmed)) @@ -2891,6 +3086,7 @@ void nano::json_handler::pending () { boost::property_tree::ptree pending_tree; pending_tree.put ("amount", info.amount.number ().convert_to ()); + pending_tree.put ("amount_decimal", convert_raw_to_dec (info.amount.number ().convert_to ())); if (source) { pending_tree.put ("source", info.source.to_account ()); @@ -2929,7 +3125,7 @@ void nano::json_handler::pending () if (source || min_version) { auto mid = hash_ptree_pairs.size () <= count ? hash_ptree_pairs.end () : hash_ptree_pairs.begin () + count; - std::partial_sort (hash_ptree_pairs.begin (), mid, hash_ptree_pairs.end (), [] (const auto & lhs, const auto & rhs) { + std::partial_sort (hash_ptree_pairs.begin (), mid, hash_ptree_pairs.end (), [] (auto const & lhs, auto const & rhs) { return lhs.second.template get ("amount") > rhs.second.template get ("amount"); }); for (auto i = 0; i < hash_ptree_pairs.size () && i < count; ++i) @@ -2940,7 +3136,7 @@ void nano::json_handler::pending () else { auto mid = hash_amount_pairs.size () <= count ? hash_amount_pairs.end () : hash_amount_pairs.begin () + count; - std::partial_sort (hash_amount_pairs.begin (), mid, hash_amount_pairs.end (), [] (const auto & lhs, const auto & rhs) { + std::partial_sort (hash_amount_pairs.begin (), mid, hash_amount_pairs.end (), [] (auto const & lhs, auto const & rhs) { return lhs.second > rhs.second; }); @@ -2958,19 +3154,19 @@ void nano::json_handler::pending () void nano::json_handler::pending_exists () { auto hash (hash_impl ()); - const bool include_active = request.get ("include_active", false); - const bool include_only_confirmed = request.get ("include_only_confirmed", true); + bool const include_active = request.get ("include_active", false); + bool const include_only_confirmed = request.get ("include_only_confirmed", true); if (!ec) { auto transaction (node.store.tx_begin_read ()); - auto block (node.store.block_get (transaction, hash)); + auto block (node.store.block.get (transaction, hash)); if (block != nullptr) { auto exists (false); auto destination (node.ledger.block_destination (transaction, *block)); if (!destination.is_zero ()) { - exists = node.store.pending_exists (transaction, nano::pending_key (destination, hash)); + exists = node.store.pending.exists (transaction, nano::pending_key (destination, hash)); } exists = exists && (block_confirmed (node, transaction, block->hash (), include_active, include_only_confirmed)); response_l.put ("exists", exists ? "1" : "0"); @@ -2986,7 +3182,7 @@ void nano::json_handler::pending_exists () void nano::json_handler::process () { node.workers.push_task (create_worker_task ([] (std::shared_ptr const & rpc_l) { - const bool is_async = rpc_l->request.get ("async", false); + bool const is_async = rpc_l->request.get ("async", false); auto block (rpc_l->block_impl (true)); // State blocks subtype check @@ -2997,7 +3193,7 @@ void nano::json_handler::process () { std::shared_ptr block_state (std::static_pointer_cast (block)); auto transaction (rpc_l->node.store.tx_begin_read ()); - if (!block_state->hashables.previous.is_zero () && !rpc_l->node.store.block_exists (transaction, block_state->hashables.previous)) + if (!block_state->hashables.previous.is_zero () && !rpc_l->node.store.block.exists (transaction, block_state->hashables.previous)) { rpc_l->ec = nano::error_process::gap_previous; } @@ -3058,7 +3254,7 @@ void nano::json_handler::process () } if (!rpc_l->ec) { - if (!nano::work_validate_entry (*block)) + if (!rpc_l->node.network_params.work.validate_entry (*block)) { if (!is_async) { @@ -3118,7 +3314,7 @@ void nano::json_handler::process () } case nano::process_result::fork: { - const bool force = rpc_l->request.get ("force", false); + bool const force = rpc_l->request.get ("force", false); if (force) { rpc_l->node.active.erase (*block); @@ -3173,7 +3369,7 @@ void nano::json_handler::pruned_exists () auto transaction (node.store.tx_begin_read ()); if (node.ledger.pruning) { - auto exists (node.store.pruned_exists (transaction, hash)); + auto exists (node.store.pruned.exists (transaction, hash)); response_l.put ("exists", exists ? "1" : "0"); } else @@ -3200,7 +3396,7 @@ void nano::json_handler::receive () if (node.ledger.block_or_pruned_exists (block_transaction, hash)) { nano::pending_info pending_info; - if (!node.store.pending_get (block_transaction, nano::pending_key (account, hash), pending_info)) + if (!node.store.pending.get (block_transaction, nano::pending_key (account, hash), pending_info)) { auto work (work_optional_impl ()); if (!ec && work) @@ -3208,7 +3404,7 @@ void nano::json_handler::receive () nano::account_info info; nano::root head; nano::epoch epoch = pending_info.epoch; - if (!node.store.account_get (block_transaction, account, info)) + if (!node.store.account.get (block_transaction, account, info)) { head = info.head; // When receiving, epoch version is the higher between the previous and the source blocks @@ -3219,7 +3415,7 @@ void nano::json_handler::receive () head = account; } nano::block_details details (epoch, false, true, false); - if (nano::work_difficulty (nano::work_version::work_1, head, work) < nano::work_threshold (nano::work_version::work_1, details)) + if (node.network_params.work.difficulty (nano::work_version::work_1, head, work) < node.network_params.work.threshold (nano::work_version::work_1, details)) { ec = nano::error_common::invalid_work; } @@ -3239,7 +3435,7 @@ void nano::json_handler::receive () bool generate_work (work == 0); // Disable work generation if "work" option is provided auto response_a (response); wallet->receive_async ( - hash, representative, node.network_params.ledger.genesis_amount, account, [response_a] (std::shared_ptr const & block_a) { + hash, representative, nano::dev::constants.genesis_amount, account, [response_a] (std::shared_ptr const & block_a) { if (block_a != nullptr) { boost::property_tree::ptree response_l; @@ -3299,7 +3495,7 @@ void nano::json_handler::representatives () auto count (count_optional_impl ()); if (!ec) { - const bool sorting = request.get ("sorting", false); + bool const sorting = request.get ("sorting", false); boost::property_tree::ptree representatives; auto rep_amounts = node.ledger.cache.rep_weights.get_rep_amounts (); if (!sorting) // Simple @@ -3339,10 +3535,55 @@ void nano::json_handler::representatives () response_errors (); } +void nano::json_handler::representatives_decimal_millions () +{ + auto count (count_optional_impl ()); + if (!ec) + { + bool const sorting = request.get ("sorting", false); + boost::property_tree::ptree representatives; + auto rep_amounts = node.ledger.cache.rep_weights.get_rep_amounts (); + if (!sorting) // Simple + { + std::map ordered (rep_amounts.begin (), rep_amounts.end ()); + for (auto & rep_amount : rep_amounts) + { + auto const & account (rep_amount.first); + auto const & amount (rep_amount.second); + representatives.put (account.to_account (), convert_raw_to_dec (amount.convert_to ())); + + if (representatives.size () > count) + { + break; + } + } + } + else // Sorting + { + std::vector> representation; + + for (auto & rep_amount : rep_amounts) + { + auto const & account (rep_amount.first); + auto const & amount (rep_amount.second); + representation.emplace_back (amount, account.to_account ()); + } + std::sort (representation.begin (), representation.end ()); + std::reverse (representation.begin (), representation.end ()); + for (auto i (representation.begin ()), n (representation.end ()); i != n && representatives.size () < count; ++i) + { + representatives.put (i->second, (i->first).convert_to ()); + } + } + response_l.add_child ("representatives", representatives); + } + response_errors (); +} + void nano::json_handler::representatives_online () { - const auto accounts_node = request.get_child_optional ("accounts"); - const bool weight = request.get ("weight", false); + auto const accounts_node = request.get_child_optional ("accounts"); + bool const weight = request.get ("weight", false); std::vector accounts_to_filter; if (accounts_node.is_initialized ()) { @@ -3386,6 +3627,7 @@ void nano::json_handler::representatives_online () boost::property_tree::ptree weight_node; auto account_weight (node.ledger.weight (i)); weight_node.put ("weight", account_weight.convert_to ()); + weight_node.put ("weight_decimal", convert_raw_to_dec (account_weight.convert_to ())); representatives.add_child (i.to_account (), weight_node); } else @@ -3426,28 +3668,28 @@ void nano::json_handler::republish () { boost::property_tree::ptree blocks; auto transaction (node.store.tx_begin_read ()); - auto block (node.store.block_get (transaction, hash)); + auto block (node.store.block.get (transaction, hash)); if (block != nullptr) { std::deque> republish_bundle; for (auto i (0); !hash.is_zero () && i < count; ++i) { - block = node.store.block_get (transaction, hash); + block = node.store.block.get (transaction, hash); if (sources != 0) // Republish source chain { nano::block_hash source (node.ledger.block_source (transaction, *block)); - auto block_a (node.store.block_get (transaction, source)); + auto block_a (node.store.block.get (transaction, source)); std::vector hashes; while (block_a != nullptr && hashes.size () < sources) { hashes.push_back (source); source = block_a->previous (); - block_a = node.store.block_get (transaction, source); + block_a = node.store.block.get (transaction, source); } std::reverse (hashes.begin (), hashes.end ()); for (auto & hash_l : hashes) { - block_a = node.store.block_get (transaction, hash_l); + block_a = node.store.block.get (transaction, hash_l); republish_bundle.push_back (std::move (block_a)); boost::property_tree::ptree entry_l; entry_l.put ("", hash_l.to_string ()); @@ -3460,14 +3702,14 @@ void nano::json_handler::republish () blocks.push_back (std::make_pair ("", entry)); if (destinations != 0) // Republish destination chain { - auto block_b (node.store.block_get (transaction, hash)); + auto block_b (node.store.block.get (transaction, hash)); auto destination (node.ledger.block_destination (transaction, *block_b)); if (!destination.is_zero ()) { - if (!node.store.pending_exists (transaction, nano::pending_key (destination, hash))) + if (!node.store.pending.exists (transaction, nano::pending_key (destination, hash))) { nano::block_hash previous (node.ledger.latest (transaction, destination)); - auto block_d (node.store.block_get (transaction, previous)); + auto block_d (node.store.block.get (transaction, previous)); nano::block_hash source; std::vector hashes; while (block_d != nullptr && hash != source) @@ -3475,7 +3717,7 @@ void nano::json_handler::republish () hashes.push_back (previous); source = node.ledger.block_source (transaction, *block_d); previous = block_d->previous (); - block_d = node.store.block_get (transaction, previous); + block_d = node.store.block.get (transaction, previous); } std::reverse (hashes.begin (), hashes.end ()); if (hashes.size () > destinations) @@ -3484,7 +3726,7 @@ void nano::json_handler::republish () } for (auto & hash_l : hashes) { - block_d = node.store.block_get (transaction, hash_l); + block_d = node.store.block.get (transaction, hash_l); republish_bundle.push_back (std::move (block_d)); boost::property_tree::ptree entry_l; entry_l.put ("", hash_l.to_string ()); @@ -3493,7 +3735,7 @@ void nano::json_handler::republish () } } } - hash = node.store.block_successor (transaction, hash); + hash = node.store.block.successor (transaction, hash); } node.network.flood_block_many (std::move (republish_bundle), nullptr, 25); response_l.put ("success", ""); // obsolete @@ -3563,7 +3805,7 @@ void nano::json_handler::send () if (!ec && work) { nano::block_details details (info.epoch (), true, false, false); - if (nano::work_difficulty (nano::work_version::work_1, info.head, work) < nano::work_threshold (nano::work_version::work_1, details)) + if (node.network_params.work.difficulty (nano::work_version::work_1, info.head, work) < node.network_params.work.threshold (nano::work_version::work_1, details)) { ec = nano::error_common::invalid_work; } @@ -3609,7 +3851,7 @@ void nano::json_handler::send () void nano::json_handler::sign () { - const bool json_block_l = request.get ("json_block", false); + bool const json_block_l = request.get ("json_block", false); // Retrieving hash nano::block_hash hash (0); boost::optional hash_text (request.get_optional ("hash")); @@ -3760,7 +4002,6 @@ void nano::json_handler::stop () response_errors (); if (!ec) { - node.stop (); stop_callback (); } } @@ -3930,13 +4171,13 @@ void nano::json_handler::telemetry () void nano::json_handler::unchecked () { - const bool json_block_l = request.get ("json_block", false); + bool const json_block_l = request.get ("json_block", false); auto count (count_optional_impl ()); if (!ec) { boost::property_tree::ptree unchecked; auto transaction (node.store.tx_begin_read ()); - for (auto i (node.store.unchecked_begin (transaction)), n (node.store.unchecked_end ()); i != n && unchecked.size () < count; ++i) + for (auto i (node.store.unchecked.begin (transaction)), n (node.store.unchecked.end ()); i != n && unchecked.size () < count; ++i) { nano::unchecked_info const & info (i->second); if (json_block_l) @@ -3961,7 +4202,7 @@ void nano::json_handler::unchecked_clear () { node.workers.push_task (create_worker_task ([] (std::shared_ptr const & rpc_l) { auto transaction (rpc_l->node.store.tx_begin_write ({ tables::unchecked })); - rpc_l->node.store.unchecked_clear (transaction); + rpc_l->node.store.unchecked.clear (transaction); rpc_l->response_l.put ("success", ""); rpc_l->response_errors (); })); @@ -3969,12 +4210,12 @@ void nano::json_handler::unchecked_clear () void nano::json_handler::unchecked_get () { - const bool json_block_l = request.get ("json_block", false); + bool const json_block_l = request.get ("json_block", false); auto hash (hash_impl ()); if (!ec) { auto transaction (node.store.tx_begin_read ()); - for (auto i (node.store.unchecked_begin (transaction)), n (node.store.unchecked_end ()); i != n; ++i) + for (auto i (node.store.unchecked.begin (transaction)), n (node.store.unchecked.end ()); i != n; ++i) { nano::unchecked_key const & key (i->first); if (key.hash == hash) @@ -4007,7 +4248,7 @@ void nano::json_handler::unchecked_get () void nano::json_handler::unchecked_keys () { - const bool json_block_l = request.get ("json_block", false); + bool const json_block_l = request.get ("json_block", false); auto count (count_optional_impl ()); nano::block_hash key (0); boost::optional hash_text (request.get_optional ("key")); @@ -4022,7 +4263,7 @@ void nano::json_handler::unchecked_keys () { boost::property_tree::ptree unchecked; auto transaction (node.store.tx_begin_read ()); - for (auto i (node.store.unchecked_begin (transaction, nano::unchecked_key (key, 0))), n (node.store.unchecked_end ()); i != n && unchecked.size () < count; ++i) + for (auto i (node.store.unchecked.begin (transaction, nano::unchecked_key (key, 0))), n (node.store.unchecked.end ()); i != n && unchecked.size () < count; ++i) { boost::property_tree::ptree entry; nano::unchecked_info const & info (i->second); @@ -4061,8 +4302,8 @@ void nano::json_handler::unopened () if (!ec) { auto transaction (node.store.tx_begin_read ()); - auto iterator (node.store.pending_begin (transaction, nano::pending_key (start, 0))); - auto end (node.store.pending_end ()); + auto iterator (node.store.pending.begin (transaction, nano::pending_key (start, 0))); + auto end (node.store.pending.end ()); nano::account current_account (start); nano::uint128_t current_account_sum{ 0 }; boost::property_tree::ptree accounts; @@ -4071,14 +4312,14 @@ void nano::json_handler::unopened () nano::pending_key key (iterator->first); nano::account account (key.account); nano::pending_info info (iterator->second); - if (node.store.account_exists (transaction, account)) + if (node.store.account.exists (transaction, account)) { if (account.number () == std::numeric_limits::max ()) { break; } // Skip existing accounts - iterator = node.store.pending_begin (transaction, nano::pending_key (account.number () + 1, 0)); + iterator = node.store.pending.begin (transaction, nano::pending_key (account.number () + 1, 0)); } else { @@ -4118,11 +4359,11 @@ void nano::json_handler::version () { response_l.put ("rpc_version", "1"); response_l.put ("store_version", std::to_string (node.store_version ())); - response_l.put ("protocol_version", std::to_string (node.network_params.protocol.protocol_version)); + response_l.put ("protocol_version", std::to_string (node.network_params.network.protocol_version)); response_l.put ("node_vendor", boost::str (boost::format ("Banano %1%") % NANO_VERSION_STRING)); response_l.put ("store_vendor", node.store.vendor_get ()); response_l.put ("network", node.network_params.network.get_current_network_as_string ()); - response_l.put ("network_identifier", node.network_params.ledger.genesis_hash.to_string ()); + response_l.put ("network_identifier", node.network_params.ledger.genesis->hash ().to_string ()); response_l.put ("build_info", BUILD_INFO); response_errors (); } @@ -4146,7 +4387,7 @@ void nano::json_handler::wallet_add () nano::raw_key key; if (!key.decode_hex (key_text)) { - const bool generate_work = rpc_l->request.get ("work", true); + bool const generate_work = rpc_l->request.get ("work", true); auto pub (wallet->insert_adhoc (key, generate_work)); if (!pub.is_zero ()) { @@ -4208,15 +4449,32 @@ void nano::json_handler::wallet_info () nano::uint128_t balance (0); nano::uint128_t pending (0); uint64_t count (0); + uint64_t block_count (0); + uint64_t cemented_block_count (0); uint64_t deterministic_count (0); uint64_t adhoc_count (0); auto transaction (node.wallets.tx_begin_read ()); auto block_transaction (node.store.tx_begin_read ()); + for (auto i (wallet->store.begin (transaction)), n (wallet->store.end ()); i != n; ++i) { nano::account const & account (i->first); - balance = balance + node.ledger.account_balance (block_transaction, account); - pending = pending + node.ledger.account_pending (block_transaction, account); + + nano::account_info account_info{}; + if (!node.store.account.get (block_transaction, account, account_info)) + { + block_count += account_info.block_count; + } + + nano::confirmation_height_info confirmation_info{}; + if (!node.store.confirmation_height.get (block_transaction, account, confirmation_info)) + { + cemented_block_count += confirmation_info.height; + } + + balance += account_info.balance.number (); + pending += node.ledger.account_pending (block_transaction, account); + nano::key_type key_type (wallet->store.key_type (i->second)); if (key_type == nano::key_type::deterministic) { @@ -4226,16 +4484,25 @@ void nano::json_handler::wallet_info () { adhoc_count++; } - count++; + + ++count; } + uint32_t deterministic_index (wallet->store.deterministic_index_get (transaction)); response_l.put ("balance", balance.convert_to ()); + response_l.put ("balance_decimal", convert_raw_to_dec (balance.convert_to ())); response_l.put ("pending", pending.convert_to ()); + response_l.put ("pending_decimal", convert_raw_to_dec (pending.convert_to ())); + response_l.put ("receivable", pending.convert_to ()); + response_l.put ("receivable_decimal", convert_raw_to_dec (pending.convert_to ())); response_l.put ("accounts_count", std::to_string (count)); + response_l.put ("accounts_block_count", std::to_string (block_count)); + response_l.put ("accounts_cemented_block_count", std::to_string (cemented_block_count)); response_l.put ("deterministic_count", std::to_string (deterministic_count)); response_l.put ("adhoc_count", std::to_string (adhoc_count)); response_l.put ("deterministic_index", std::to_string (deterministic_index)); } + response_errors (); } @@ -4257,7 +4524,11 @@ void nano::json_handler::wallet_balances () boost::property_tree::ptree entry; nano::uint128_t pending = node.ledger.account_pending (block_transaction, account); entry.put ("balance", balance.convert_to ()); + entry.put ("balance_decimal", convert_raw_to_dec (balance.convert_to ())); entry.put ("pending", pending.convert_to ()); + entry.put ("pending_decimal", convert_raw_to_dec (pending.convert_to ())); + entry.put ("receivable", pending.convert_to ()); + entry.put ("receivable_decimal", convert_raw_to_dec (pending.convert_to ())); balances.push_back (std::make_pair (account.to_account (), entry)); } } @@ -4433,13 +4704,13 @@ void nano::json_handler::wallet_history () { nano::account const & account (i->first); nano::account_info info; - if (!node.store.account_get (block_transaction, account, info)) + if (!node.store.account.get (block_transaction, account, info)) { auto timestamp (info.modified); auto hash (info.head); while (timestamp >= modified_since && !hash.is_zero ()) { - auto block (node.store.block_get (block_transaction, hash)); + auto block (node.store.block.get (block_transaction, hash)); timestamp = block->sideband ().timestamp; if (block != nullptr && timestamp >= modified_since) { @@ -4487,9 +4758,9 @@ void nano::json_handler::wallet_key_valid () void nano::json_handler::wallet_ledger () { - const bool representative = request.get ("representative", false); - const bool weight = request.get ("weight", false); - const bool pending = request.get ("pending", false); + bool const representative = request.get ("representative", false); + bool const weight = request.get ("weight", false); + bool const pending = request.get ("pending", false); uint64_t modified_since (0); boost::optional modified_since_text (request.get_optional ("modified_since")); if (modified_since_text.is_initialized ()) @@ -4506,7 +4777,7 @@ void nano::json_handler::wallet_ledger () { nano::account const & account (i->first); nano::account_info info; - if (!node.store.account_get (block_transaction, account, info)) + if (!node.store.account.get (block_transaction, account, info)) { if (info.modified >= modified_since) { @@ -4517,6 +4788,7 @@ void nano::json_handler::wallet_ledger () std::string balance; nano::uint128_union (info.balance).encode_dec (balance); entry.put ("balance", balance); + entry.put ("balance_decimal", convert_raw_to_dec (balance)); entry.put ("modified_timestamp", std::to_string (info.modified)); entry.put ("block_count", std::to_string (info.block_count)); if (representative) @@ -4527,11 +4799,15 @@ void nano::json_handler::wallet_ledger () { auto account_weight (node.ledger.weight (account)); entry.put ("weight", account_weight.convert_to ()); + entry.put ("weight_decimal", convert_raw_to_dec (account_weight.convert_to ())); } if (pending) { auto account_pending (node.ledger.account_pending (block_transaction, account)); entry.put ("pending", account_pending.convert_to ()); + entry.put ("pending_decimal", convert_raw_to_dec (account_pending.convert_to ())); + entry.put ("receivable", account_pending.convert_to ()); + entry.put ("receivable_decimal", convert_raw_to_dec (account_pending.convert_to ())); } accounts.push_back (std::make_pair (account.to_account (), entry)); } @@ -4561,10 +4837,10 @@ void nano::json_handler::wallet_pending () auto wallet (wallet_impl ()); auto count (count_optional_impl ()); auto threshold (threshold_optional_impl ()); - const bool source = request.get ("source", false); - const bool min_version = request.get ("min_version", false); - const bool include_active = request.get ("include_active", false); - const bool include_only_confirmed = request.get ("include_only_confirmed", true); + bool const source = request.get ("source", false); + bool const min_version = request.get ("min_version", false); + bool const include_active = request.get ("include_active", false); + bool const include_only_confirmed = request.get ("include_only_confirmed", true); if (!ec) { boost::property_tree::ptree pending; @@ -4574,7 +4850,7 @@ void nano::json_handler::wallet_pending () { nano::account const & account (i->first); boost::property_tree::ptree peers_l; - for (auto ii (node.store.pending_begin (block_transaction, nano::pending_key (account, 0))), nn (node.store.pending_end ()); ii != nn && nano::pending_key (ii->first).account == account && peers_l.size () < count; ++ii) + for (auto ii (node.store.pending.begin (block_transaction, nano::pending_key (account, 0))), nn (node.store.pending.end ()); ii != nn && nano::pending_key (ii->first).account == account && peers_l.size () < count; ++ii) { nano::pending_key key (ii->first); if (block_confirmed (node, block_transaction, key.hash, include_active, include_only_confirmed)) @@ -4594,6 +4870,7 @@ void nano::json_handler::wallet_pending () { boost::property_tree::ptree pending_tree; pending_tree.put ("amount", info.amount.number ().convert_to ()); + pending_tree.put ("amount_decimal", convert_raw_to_dec (info.amount.number ().convert_to ())); if (source) { pending_tree.put ("source", info.source.to_account ()); @@ -4665,7 +4942,7 @@ void nano::json_handler::wallet_representative_set () { nano::account const & account (i->first); nano::account_info info; - if (!rpc_l->node.store.account_get (block_transaction, account, info)) + if (!rpc_l->node.store.account.get (block_transaction, account, info)) { if (info.representative != representative) { @@ -4704,7 +4981,7 @@ void nano::json_handler::wallet_republish () while (!latest.is_zero () && hashes.size () < count) { hashes.push_back (latest); - block = node.store.block_get (block_transaction, latest); + block = node.store.block.get (block_transaction, latest); if (block != nullptr) { latest = block->previous (); @@ -4717,7 +4994,7 @@ void nano::json_handler::wallet_republish () std::reverse (hashes.begin (), hashes.end ()); for (auto & hash : hashes) { - block = node.store.block_get (block_transaction, hash); + block = node.store.block.get (block_transaction, hash); republish_bundle.push_back (std::move (block)); boost::property_tree::ptree entry; entry.put ("", hash.to_string ()); @@ -4785,7 +5062,7 @@ void nano::json_handler::work_generate () auto hash (hash_impl ()); auto difficulty (difficulty_optional_impl (work_version)); multiplier_optional_impl (work_version, difficulty); - if (!ec && (difficulty > node.max_work_generate_difficulty (work_version) || difficulty < nano::work_threshold_entry (work_version, nano::block_type::state))) + if (!ec && (difficulty > node.max_work_generate_difficulty (work_version) || difficulty < node.network_params.work.threshold_entry (work_version, nano::block_type::state))) { ec = nano::error_rpc::difficulty_limit; } @@ -4814,7 +5091,7 @@ void nano::json_handler::work_generate () difficulty = difficulty_ledger (*block); } // If optional block difficulty is higher than requested difficulty, send error - if (!ec && block->difficulty () >= difficulty) + if (!ec && node.network_params.work.difficulty (*block) >= difficulty) { ec = nano::error_rpc::block_work_enough; } @@ -4832,7 +5109,7 @@ void nano::json_handler::work_generate () uint64_t work (work_a.value ()); response_l.put ("work", nano::to_string_hex (work)); std::stringstream ostream; - auto result_difficulty (nano::work_difficulty (work_version, hash, work)); + auto result_difficulty (rpc_l->node.network_params.work.difficulty (work_version, hash, work)); response_l.put ("difficulty", nano::to_string_hex (result_difficulty)); auto result_multiplier = nano::difficulty::to_multiplier (result_difficulty, node.default_difficulty (work_version)); response_l.put ("multiplier", nano::to_string (result_multiplier)); @@ -4865,9 +5142,9 @@ void nano::json_handler::work_generate () { // Fetch account from block if not given auto transaction_l (node.store.tx_begin_read ()); - if (node.store.block_exists (transaction_l, hash)) + if (node.store.block.exists (transaction_l, hash)) { - account = node.store.block_account (transaction_l, hash); + account = node.store.block.account (transaction_l, hash); } } auto secondary_work_peers_l (request.get ("secondary_work_peers", false)); @@ -4958,13 +5235,13 @@ void nano::json_handler::work_validate () * * valid_receive: the work is valid for a receive block in an epoch_2 upgraded account */ - auto result_difficulty (nano::work_difficulty (work_version, hash, work)); + auto result_difficulty (node.network_params.work.difficulty (work_version, hash, work)); if (request.count ("difficulty")) { response_l.put ("valid", (result_difficulty >= difficulty) ? "1" : "0"); } response_l.put ("valid_all", (result_difficulty >= node.default_difficulty (work_version)) ? "1" : "0"); - response_l.put ("valid_receive", (result_difficulty >= nano::work_threshold (work_version, nano::block_details (nano::epoch::epoch_2, false, true, false))) ? "1" : "0"); + response_l.put ("valid_receive", (result_difficulty >= node.network_params.work.threshold (work_version, nano::block_details (nano::epoch::epoch_2, false, true, false))) ? "1" : "0"); response_l.put ("difficulty", nano::to_string_hex (result_difficulty)); auto result_multiplier = nano::difficulty::to_multiplier (result_difficulty, node.default_difficulty (work_version)); response_l.put ("multiplier", nano::to_string (result_multiplier)); @@ -5023,7 +5300,7 @@ void nano::inprocess_rpc_handler::process_request_v2 (rpc_handler_request_params { std::string body_l = params_a.json_envelope (body_a); auto handler (std::make_shared (node, ipc_server, nullptr, node.config.ipc_config)); - handler->process_json (reinterpret_cast (body_l.data ()), body_l.size (), response_a); + handler->process_json (reinterpret_cast (body_l.data ()), body_l.size (), response_a); } namespace @@ -5072,6 +5349,7 @@ ipc_json_handler_no_arg_func_map create_ipc_json_handler_no_arg_func_map () no_arg_funcs.emplace ("account_representative_set", &nano::json_handler::account_representative_set); no_arg_funcs.emplace ("account_weight", &nano::json_handler::account_weight); no_arg_funcs.emplace ("accounts_balances", &nano::json_handler::accounts_balances); + no_arg_funcs.emplace ("accounts_representatives", &nano::json_handler::accounts_representatives); no_arg_funcs.emplace ("accounts_create", &nano::json_handler::accounts_create); no_arg_funcs.emplace ("accounts_frontiers", &nano::json_handler::accounts_frontiers); no_arg_funcs.emplace ("accounts_pending", &nano::json_handler::accounts_pending); @@ -5114,8 +5392,11 @@ ipc_json_handler_no_arg_func_map create_ipc_json_handler_no_arg_func_map () no_arg_funcs.emplace ("peers", &nano::json_handler::peers); no_arg_funcs.emplace ("pending", &nano::json_handler::pending); no_arg_funcs.emplace ("pending_exists", &nano::json_handler::pending_exists); + no_arg_funcs.emplace ("receivable", &nano::json_handler::pending); + no_arg_funcs.emplace ("receivable_exists", &nano::json_handler::pending_exists); no_arg_funcs.emplace ("process", &nano::json_handler::process); no_arg_funcs.emplace ("pruned_exists", &nano::json_handler::pruned_exists); + no_arg_funcs.emplace ("raw_to_dec", &nano::json_handler::raw_to_dec); no_arg_funcs.emplace ("receive", &nano::json_handler::receive); no_arg_funcs.emplace ("receive_minimum", &nano::json_handler::receive_minimum); no_arg_funcs.emplace ("receive_minimum_set", &nano::json_handler::receive_minimum_set); @@ -5185,14 +5466,14 @@ bool block_confirmed (nano::node & node, nano::transaction & transaction, nano:: // This just checks it's not currently undergoing an active transaction else if (!include_only_confirmed) { - auto block (node.store.block_get (transaction, hash)); + auto block (node.store.block.get (transaction, hash)); is_confirmed = (block != nullptr && !node.active.active (*block)); } return is_confirmed; } -const char * epoch_as_string (nano::epoch epoch) +char const * epoch_as_string (nano::epoch epoch) { switch (epoch) { diff --git a/nano/node/json_handler.hpp b/nano/node/json_handler.hpp index b6dbbab29d..3c09fedf04 100644 --- a/nano/node/json_handler.hpp +++ b/nano/node/json_handler.hpp @@ -40,6 +40,7 @@ class json_handler : public std::enable_shared_from_this void account_representative_set (); void account_weight (); void accounts_balances (); + void accounts_representatives (); void accounts_create (); void accounts_frontiers (); void accounts_pending (); @@ -65,6 +66,7 @@ class json_handler : public std::enable_shared_from_this void confirmation_height_currently_processing (); void database_txn_tracker (); void delegators (); + void delegators_decimal (); void delegators_count (); void deterministic_key (); void epoch_upgrade (); @@ -75,6 +77,8 @@ class json_handler : public std::enable_shared_from_this void ledger (); void mnano_to_raw (nano::uint128_t = nano::BAN_ratio); void mnano_from_raw (nano::uint128_t = nano::BAN_ratio); + void nano_to_raw (); + void raw_to_nano (); void node_id (); void node_id_delete (); void password_change (); @@ -85,10 +89,12 @@ class json_handler : public std::enable_shared_from_this void pending_exists (); void process (); void pruned_exists (); + void raw_to_dec (); void receive (); void receive_minimum (); void receive_minimum_set (); void representatives (); + void representatives_decimal_millions (); void representatives_online (); void republish (); void search_pending (); diff --git a/nano/node/ledger_walker.cpp b/nano/node/ledger_walker.cpp new file mode 100644 index 0000000000..17d24c1f57 --- /dev/null +++ b/nano/node/ledger_walker.cpp @@ -0,0 +1,180 @@ +// TODO: keep this until diskhash builds fine on Windows +#ifndef _WIN32 + +#include +#include +#include +#include +#include +#include + +#include +#include +#include + +nano::ledger_walker::ledger_walker (nano::ledger const & ledger_a) : + ledger{ ledger_a }, + use_in_memory_walked_blocks{ true }, + walked_blocks{}, + walked_blocks_disk{}, + blocks_to_walk{} +{ + debug_assert (!ledger.store.init_error ()); +} + +void nano::ledger_walker::walk_backward (nano::block_hash const & start_block_hash_a, should_visit_callback const & should_visit_callback_a, visitor_callback const & visitor_callback_a) +{ + auto const transaction = ledger.store.tx_begin_read (); + + enqueue_block (start_block_hash_a); + while (!blocks_to_walk.empty ()) + { + auto const block = dequeue_block (transaction); + if (!should_visit_callback_a (block)) + { + continue; + } + + visitor_callback_a (block); + for (auto const & hash : ledger.dependent_blocks (transaction, *block)) + { + if (!hash.is_zero ()) + { + auto const dependent_block = ledger.store.block.get (transaction, hash); + if (dependent_block) + { + enqueue_block (dependent_block); + } + } + } + } + + clear_queue (); +} + +void nano::ledger_walker::walk (nano::block_hash const & end_block_hash_a, should_visit_callback const & should_visit_callback_a, visitor_callback const & visitor_callback_a) +{ + std::uint64_t last_walked_block_order_index = 0; + dht::DiskHash walked_blocks_order{ nano::unique_path ().c_str (), static_cast (std::to_string (std::numeric_limits::max ()).size ()) + 1, dht::DHOpenRW }; + + walk_backward (end_block_hash_a, + should_visit_callback_a, + [&] (auto const & block) { + walked_blocks_order.insert (std::to_string (++last_walked_block_order_index).c_str (), block->hash ()); + }); + + auto const transaction = ledger.store.tx_begin_read (); + for (auto walked_block_order_index = last_walked_block_order_index; walked_block_order_index != 0; --walked_block_order_index) + { + auto const * block_hash = walked_blocks_order.lookup (std::to_string (walked_block_order_index).c_str ()); + if (!block_hash) + { + debug_assert (false); + continue; + } + + auto const block = ledger.store.block.get (transaction, *block_hash); + if (!block) + { + debug_assert (false); + continue; + } + + visitor_callback_a (block); + } +} + +void nano::ledger_walker::walk_backward (nano::block_hash const & start_block_hash_a, visitor_callback const & visitor_callback_a) +{ + walk_backward ( + start_block_hash_a, + [&] (auto const & /* block */) { + return true; + }, + visitor_callback_a); +} + +void nano::ledger_walker::walk (nano::block_hash const & end_block_hash_a, visitor_callback const & visitor_callback_a) +{ + walk ( + end_block_hash_a, + [&] (auto const & /* block */) { + return true; + }, + visitor_callback_a); +} + +void nano::ledger_walker::enqueue_block (nano::block_hash block_hash_a) +{ + if (add_to_walked_blocks (block_hash_a)) + { + blocks_to_walk.emplace (std::move (block_hash_a)); + } +} + +void nano::ledger_walker::enqueue_block (std::shared_ptr const & block_a) +{ + debug_assert (block_a); + enqueue_block (block_a->hash ()); +} + +bool nano::ledger_walker::add_to_walked_blocks (nano::block_hash const & block_hash_a) +{ + if (use_in_memory_walked_blocks) + { + if (walked_blocks.size () < in_memory_block_count) + { + return walked_blocks.emplace (block_hash_a).second; + } + + use_in_memory_walked_blocks = false; + + debug_assert (!walked_blocks_disk.has_value ()); + walked_blocks_disk.emplace (nano::unique_path ().c_str (), sizeof (nano::block_hash::bytes) + 1, dht::DHOpenRW); + + for (auto const & walked_block_hash : walked_blocks) + { + if (!add_to_walked_blocks_disk (walked_block_hash)) + { + debug_assert (false); + } + } + + decltype (walked_blocks){}.swap (walked_blocks); + } + + return add_to_walked_blocks_disk (block_hash_a); +} + +bool nano::ledger_walker::add_to_walked_blocks_disk (nano::block_hash const & block_hash_a) +{ + debug_assert (!use_in_memory_walked_blocks); + debug_assert (walked_blocks_disk.has_value ()); + + std::array block_hash_key{}; + std::copy (block_hash_a.chars.cbegin (), + block_hash_a.chars.cend (), + block_hash_key.begin ()); + + return walked_blocks_disk->insert (block_hash_key.data (), true); +} + +void nano::ledger_walker::clear_queue () +{ + use_in_memory_walked_blocks = true; + + decltype (walked_blocks){}.swap (walked_blocks); + walked_blocks_disk.reset (); + + decltype (blocks_to_walk){}.swap (blocks_to_walk); +} + +std::shared_ptr nano::ledger_walker::dequeue_block (nano::transaction const & transaction_a) +{ + auto block = ledger.store.block.get (transaction_a, blocks_to_walk.top ()); + blocks_to_walk.pop (); + + return block; +} + +#endif // _WIN32 -- TODO: keep this until diskhash builds fine on Windows diff --git a/nano/node/ledger_walker.hpp b/nano/node/ledger_walker.hpp new file mode 100644 index 0000000000..6458d8acdc --- /dev/null +++ b/nano/node/ledger_walker.hpp @@ -0,0 +1,65 @@ +// TODO: keep this until diskhash builds fine on Windows +#ifndef _WIN32 + +#pragma once + +#include + +#include +#include +#include +#include +#include +#include + +#include + +namespace nano +{ +class block; +class ledger; +class transaction; + +/** Walks the ledger starting from a start block and applying a depth-first search algorithm */ +class ledger_walker final +{ +public: + using should_visit_callback = std::function const &)>; + using visitor_callback = std::function const &)>; + + explicit ledger_walker (nano::ledger const & ledger_a); + + /** Start traversing (in a backwards direction -- towards genesis) from \p start_block_hash_a until \p should_visit_callback_a returns false, calling \p visitor_callback_a at each block. Prefer 'walk' instead, if possible. */ + void walk_backward (nano::block_hash const & start_block_hash_a, should_visit_callback const & should_visit_callback_a, visitor_callback const & visitor_callback_a); + + /** Start traversing (in a forward direction -- towards end_block_hash_a) from first block (genesis onwards) where \p should_visit_a returns true until \p end_block_hash_a, calling \p visitor_callback at each block. Prefer this one, instead of 'walk_backwards', if possible. */ + void walk (nano::block_hash const & end_block_hash_a, should_visit_callback const & should_visit_callback_a, visitor_callback const & visitor_callback_a); + + /** Methods similar to walk_backward and walk, but that do not offer the possibility of providing a user-defined should_visit_callback function. */ + void walk_backward (nano::block_hash const & start_block_hash_a, visitor_callback const & visitor_callback_a); + void walk (nano::block_hash const & end_block_hash_a, visitor_callback const & visitor_callback_a); + + /** How many blocks will be held in the in-memory hash before using the disk hash for walking. */ + // TODO TSB: make this 65536 + static constexpr std::size_t in_memory_block_count = 0; + +private: + nano::ledger const & ledger; + bool use_in_memory_walked_blocks; + std::unordered_set walked_blocks; + std::optional> walked_blocks_disk; + std::stack blocks_to_walk; + + void enqueue_block (nano::block_hash block_hash_a); + void enqueue_block (std::shared_ptr const & block_a); + bool add_to_walked_blocks (nano::block_hash const & block_hash_a); + bool add_to_walked_blocks_disk (nano::block_hash const & block_hash_a); + void clear_queue (); + std::shared_ptr dequeue_block (nano::transaction const & transaction_a); + + friend class ledger_walker_genesis_account_longer_Test; +}; + +} + +#endif // _WIN32 -- TODO: keep this until diskhash builds fine on Windows diff --git a/nano/node/lmdb/lmdb.cpp b/nano/node/lmdb/lmdb.cpp index cbb117fc5b..13b4cfd7cb 100644 --- a/nano/node/lmdb/lmdb.cpp +++ b/nano/node/lmdb/lmdb.cpp @@ -22,13 +22,13 @@ void * mdb_val::data () const } template <> -size_t mdb_val::size () const +std::size_t mdb_val::size () const { return value.mv_size; } template <> -mdb_val::db_val (size_t size_a, void * data_a) : +mdb_val::db_val (std::size_t size_a, void * data_a) : value ({ size_a, data_a }) { } @@ -40,7 +40,34 @@ void mdb_val::convert_buffer_to_value () } } -nano::mdb_store::mdb_store (nano::logger_mt & logger_a, boost::filesystem::path const & path_a, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, nano::lmdb_config const & lmdb_config_a, bool backup_before_upgrade_a) : +nano::mdb_store::mdb_store (nano::logger_mt & logger_a, boost::filesystem::path const & path_a, nano::ledger_constants & constants, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, nano::lmdb_config const & lmdb_config_a, bool backup_before_upgrade_a) : + // clang-format off + store_partial{ + constants, + block_store_partial, + frontier_store_partial, + account_store_partial, + pending_store_partial, + unchecked_mdb_store, + online_weight_store_partial, + pruned_store_partial, + peer_store_partial, + confirmation_height_store_partial, + final_vote_store_partial, + version_store_partial + }, + // clang-format on + block_store_partial{ *this }, + frontier_store_partial{ *this }, + account_store_partial{ *this }, + pending_store_partial{ *this }, + online_weight_store_partial{ *this }, + pruned_store_partial{ *this }, + peer_store_partial{ *this }, + confirmation_height_store_partial{ *this }, + final_vote_store_partial{ *this }, + unchecked_mdb_store{ *this }, + version_store_partial{ *this }, logger (logger_a), env (error, path_a, nano::mdb_env::options::make ().set_config (lmdb_config_a).set_use_no_mem_init (true)), mdb_txn_tracker (logger_a, txn_tracking_config_a, block_processor_batch_max_time_a), @@ -52,12 +79,12 @@ nano::mdb_store::mdb_store (nano::logger_mt & logger_a, boost::filesystem::path auto is_fresh_db (false); { auto transaction (tx_begin_read ()); - auto err = mdb_dbi_open (env.tx (transaction), "meta", 0, &meta); + auto err = mdb_dbi_open (env.tx (transaction), "meta", 0, &meta_handle); is_fresh_db = err != MDB_SUCCESS; if (err == MDB_SUCCESS) { - is_fully_upgraded = (version_get (transaction) == version); - mdb_dbi_close (env, meta); + is_fully_upgraded = (version.get (transaction) == version_number); + mdb_dbi_close (env, meta_handle); } } @@ -66,13 +93,9 @@ nano::mdb_store::mdb_store (nano::logger_mt & logger_a, boost::filesystem::path // (can be a few minutes with the --fast_bootstrap flag for instance) if (!is_fully_upgraded) { - nano::network_constants network_constants; if (!is_fresh_db) { - if (!network_constants.is_dev_network ()) - { - std::cout << "Upgrade in progress..." << std::endl; - } + logger.always_log ("Upgrade in progress..."); if (backup_before_upgrade_a) { create_backup_file (env, path_a, logger_a); @@ -88,7 +111,7 @@ nano::mdb_store::mdb_store (nano::logger_mt & logger_a, boost::filesystem::path } } - if (needs_vacuuming && !network_constants.is_dev_network ()) + if (needs_vacuuming) { logger.always_log ("Preparing vacuum..."); auto vacuum_success = vacuum_after_upgrade (path_a, lmdb_config_a); @@ -176,10 +199,10 @@ nano::mdb_txn_callbacks nano::mdb_store::create_txn_callbacks () const nano::mdb_txn_callbacks mdb_txn_callbacks; if (txn_tracking_enabled) { - mdb_txn_callbacks.txn_start = ([&mdb_txn_tracker = mdb_txn_tracker] (const nano::transaction_impl * transaction_impl) { + mdb_txn_callbacks.txn_start = ([&mdb_txn_tracker = mdb_txn_tracker] (nano::transaction_impl const * transaction_impl) { mdb_txn_tracker.add (transaction_impl); }); - mdb_txn_callbacks.txn_end = ([&mdb_txn_tracker = mdb_txn_tracker] (const nano::transaction_impl * transaction_impl) { + mdb_txn_callbacks.txn_end = ([&mdb_txn_tracker = mdb_txn_tracker] (nano::transaction_impl const * transaction_impl) { mdb_txn_tracker.erase (transaction_impl); }); } @@ -188,59 +211,59 @@ nano::mdb_txn_callbacks nano::mdb_store::create_txn_callbacks () const void nano::mdb_store::open_databases (bool & error_a, nano::transaction const & transaction_a, unsigned flags) { - error_a |= mdb_dbi_open (env.tx (transaction_a), "frontiers", flags, &frontiers) != 0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "unchecked", flags, &unchecked) != 0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "online_weight", flags, &online_weight) != 0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "meta", flags, &meta) != 0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "peers", flags, &peers) != 0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "pruned", flags, &pruned) != 0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "confirmation_height", flags, &confirmation_height) != 0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "accounts", flags, &accounts_v0) != 0; - accounts = accounts_v0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "pending", flags, &pending_v0) != 0; - pending = pending_v0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "final_votes", flags, &final_votes) != 0; - - auto version_l = version_get (transaction_a); + error_a |= mdb_dbi_open (env.tx (transaction_a), "frontiers", flags, &frontiers_handle) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "unchecked", flags, &unchecked_handle) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "online_weight", flags, &online_weight_handle) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "meta", flags, &meta_handle) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "peers", flags, &peers_handle) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "pruned", flags, &pruned_handle) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "confirmation_height", flags, &confirmation_height_handle) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "accounts", flags, &accounts_v0_handle) != 0; + accounts_handle = accounts_v0_handle; + error_a |= mdb_dbi_open (env.tx (transaction_a), "pending", flags, &pending_v0_handle) != 0; + pending_handle = pending_v0_handle; + error_a |= mdb_dbi_open (env.tx (transaction_a), "final_votes", flags, &final_votes_handle) != 0; + + auto version_l = version.get (transaction_a); if (version_l < 19) { // These legacy (and state) block databases are no longer used, but need opening so they can be deleted during an upgrade - error_a |= mdb_dbi_open (env.tx (transaction_a), "send", flags, &send_blocks) != 0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "receive", flags, &receive_blocks) != 0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "open", flags, &open_blocks) != 0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "change", flags, &change_blocks) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "send", flags, &send_blocks_handle) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "receive", flags, &receive_blocks_handle) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "open", flags, &open_blocks_handle) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "change", flags, &change_blocks_handle) != 0; if (version_l >= 15) { - error_a |= mdb_dbi_open (env.tx (transaction_a), "state_blocks", flags, &state_blocks) != 0; - state_blocks_v0 = state_blocks; + error_a |= mdb_dbi_open (env.tx (transaction_a), "state_blocks", flags, &state_blocks_handle) != 0; + state_blocks_v0_handle = state_blocks_handle; } } else { - error_a |= mdb_dbi_open (env.tx (transaction_a), "blocks", MDB_CREATE, &blocks) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "blocks", MDB_CREATE, &blocks_handle) != 0; } if (version_l < 16) { // The representation database is no longer used, but needs opening so that it can be deleted during an upgrade - error_a |= mdb_dbi_open (env.tx (transaction_a), "representation", flags, &representation) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "representation", flags, &representation_handle) != 0; } if (version_l < 15) { // These databases are no longer used, but need opening so they can be deleted during an upgrade - error_a |= mdb_dbi_open (env.tx (transaction_a), "state", flags, &state_blocks_v0) != 0; - state_blocks = state_blocks_v0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "accounts_v1", flags, &accounts_v1) != 0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "pending_v1", flags, &pending_v1) != 0; - error_a |= mdb_dbi_open (env.tx (transaction_a), "state_v1", flags, &state_blocks_v1) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "state", flags, &state_blocks_v0_handle) != 0; + state_blocks_handle = state_blocks_v0_handle; + error_a |= mdb_dbi_open (env.tx (transaction_a), "accounts_v1", flags, &accounts_v1_handle) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "pending_v1", flags, &pending_v1_handle) != 0; + error_a |= mdb_dbi_open (env.tx (transaction_a), "state_v1", flags, &state_blocks_v1_handle) != 0; } } bool nano::mdb_store::do_upgrades (nano::write_transaction & transaction_a, bool & needs_vacuuming) { auto error (false); - auto version_l = version_get (transaction_a); + auto version_l = version.get (transaction_a); switch (version_l) { case 1: @@ -298,10 +321,10 @@ void nano::mdb_store::upgrade_v14_to_v15 (nano::write_transaction & transaction_ logger.always_log ("Preparing v14 to v15 database upgrade..."); std::vector> account_infos; - upgrade_counters account_counters (count (transaction_a, accounts_v0), count (transaction_a, accounts_v1)); + upgrade_counters account_counters (count (transaction_a, accounts_v0_handle), count (transaction_a, accounts_v1_handle)); account_infos.reserve (account_counters.before_v0 + account_counters.before_v1); - nano::mdb_merge_iterator i_account (transaction_a, accounts_v0, accounts_v1); + nano::mdb_merge_iterator i_account (transaction_a, accounts_v0_handle, accounts_v1_handle); nano::mdb_merge_iterator n_account{}; for (; i_account != n_account; ++i_account) { @@ -313,7 +336,7 @@ void nano::mdb_store::upgrade_v14_to_v15 (nano::write_transaction & transaction_ release_assert (rep_block != nullptr); account_infos.emplace_back (account, nano::account_info{ account_info_v14.head, rep_block->representative (), account_info_v14.open_block, account_info_v14.balance, account_info_v14.modified, account_info_v14.block_count, i_account.from_first_database ? nano::epoch::epoch_0 : nano::epoch::epoch_1 }); // Move confirmation height from account_info database to its own table - mdb_put (env.tx (transaction_a), confirmation_height, nano::mdb_val (account), nano::mdb_val (account_info_v14.confirmation_height), MDB_APPEND); + mdb_put (env.tx (transaction_a), confirmation_height_handle, nano::mdb_val (account), nano::mdb_val (account_info_v14.confirmation_height), MDB_APPEND); i_account.from_first_database ? ++account_counters.after_v0 : ++account_counters.after_v1; } @@ -321,13 +344,13 @@ void nano::mdb_store::upgrade_v14_to_v15 (nano::write_transaction & transaction_ debug_assert (account_counters.are_equal ()); // No longer need accounts_v1, keep v0 but clear it - mdb_drop (env.tx (transaction_a), accounts_v1, 1); - mdb_drop (env.tx (transaction_a), accounts_v0, 0); + mdb_drop (env.tx (transaction_a), accounts_v1_handle, 1); + mdb_drop (env.tx (transaction_a), accounts_v0_handle, 0); for (auto const & account_account_info_pair : account_infos) { auto const & account_info (account_account_info_pair.second); - mdb_put (env.tx (transaction_a), accounts, nano::mdb_val (account_account_info_pair.first), nano::mdb_val (account_info), MDB_APPEND); + mdb_put (env.tx (transaction_a), accounts_handle, nano::mdb_val (account_account_info_pair.first), nano::mdb_val (account_info), MDB_APPEND); } logger.always_log ("Epoch merge upgrade: Finished accounts, now doing state blocks"); @@ -338,9 +361,9 @@ void nano::mdb_store::upgrade_v14_to_v15 (nano::write_transaction & transaction_ MDB_dbi state_blocks_new; mdb_dbi_open (env.tx (transaction_a), "state_blocks", MDB_CREATE, &state_blocks_new); - upgrade_counters state_counters (count (transaction_a, state_blocks_v0), count (transaction_a, state_blocks_v1)); + upgrade_counters state_counters (count (transaction_a, state_blocks_v0_handle), count (transaction_a, state_blocks_v1_handle)); - nano::mdb_merge_iterator i_state (transaction_a, state_blocks_v0, state_blocks_v1); + nano::mdb_merge_iterator i_state (transaction_a, state_blocks_v0_handle, state_blocks_v1_handle); nano::mdb_merge_iterator n_state{}; auto num = 0u; for (; i_state != n_state; ++i_state, ++num) @@ -361,7 +384,7 @@ void nano::mdb_store::upgrade_v14_to_v15 (nano::write_transaction & transaction_ nano::mdb_val value{ data.size (), (void *)data.data () }; auto s = mdb_put (env.tx (transaction_a), state_blocks_new, nano::mdb_val (hash), value, MDB_APPEND); - release_assert_success (s); + release_assert_success (*this, s); // Every so often output to the log to indicate progress constexpr auto output_cutoff = 1000000; @@ -375,19 +398,19 @@ void nano::mdb_store::upgrade_v14_to_v15 (nano::write_transaction & transaction_ debug_assert (state_counters.are_equal ()); logger.always_log ("Epoch merge upgrade: Finished state blocks, now doing pending blocks"); - state_blocks = state_blocks_new; + state_blocks_handle = state_blocks_new; // No longer need states v0/v1 databases - mdb_drop (env.tx (transaction_a), state_blocks_v1, 1); - mdb_drop (env.tx (transaction_a), state_blocks_v0, 1); + mdb_drop (env.tx (transaction_a), state_blocks_v1_handle, 1); + mdb_drop (env.tx (transaction_a), state_blocks_v0_handle, 1); - state_blocks_v0 = state_blocks; + state_blocks_v0_handle = state_blocks_handle; - upgrade_counters pending_counters (count (transaction_a, pending_v0), count (transaction_a, pending_v1)); + upgrade_counters pending_counters (count (transaction_a, pending_v0_handle), count (transaction_a, pending_v1_handle)); std::vector> pending_infos; pending_infos.reserve (pending_counters.before_v0 + pending_counters.before_v1); - nano::mdb_merge_iterator i_pending (transaction_a, pending_v0, pending_v1); + nano::mdb_merge_iterator i_pending (transaction_a, pending_v0_handle, pending_v1_handle); nano::mdb_merge_iterator n_pending{}; for (; i_pending != n_pending; ++i_pending) { @@ -399,42 +422,42 @@ void nano::mdb_store::upgrade_v14_to_v15 (nano::write_transaction & transaction_ debug_assert (pending_counters.are_equal ()); // No longer need the pending v1 table - mdb_drop (env.tx (transaction_a), pending_v1, 1); - mdb_drop (env.tx (transaction_a), pending_v0, 0); + mdb_drop (env.tx (transaction_a), pending_v1_handle, 1); + mdb_drop (env.tx (transaction_a), pending_v0_handle, 0); for (auto const & pending_key_pending_info_pair : pending_infos) { - mdb_put (env.tx (transaction_a), pending, nano::mdb_val (pending_key_pending_info_pair.first), nano::mdb_val (pending_key_pending_info_pair.second), MDB_APPEND); + mdb_put (env.tx (transaction_a), pending_handle, nano::mdb_val (pending_key_pending_info_pair.first), nano::mdb_val (pending_key_pending_info_pair.second), MDB_APPEND); } - version_put (transaction_a, 15); + version.put (transaction_a, 15); logger.always_log ("Finished epoch merge upgrade"); } void nano::mdb_store::upgrade_v15_to_v16 (nano::write_transaction const & transaction_a) { // Representation table is no longer used - debug_assert (representation != 0); - if (representation != 0) + debug_assert (representation_handle != 0); + if (representation_handle != 0) { - auto status (mdb_drop (env.tx (transaction_a), representation, 1)); + auto status (mdb_drop (env.tx (transaction_a), representation_handle, 1)); release_assert (status == MDB_SUCCESS); - representation = 0; + representation_handle = 0; } - version_put (transaction_a, 16); + version.put (transaction_a, 16); } void nano::mdb_store::upgrade_v16_to_v17 (nano::write_transaction const & transaction_a) { logger.always_log ("Preparing v16 to v17 database upgrade..."); - auto account_info_i = accounts_begin (transaction_a); - auto account_info_n = accounts_end (); + auto account_info_i = account.begin (transaction_a); + auto account_info_n = account.end (); // Set the confirmed frontier for each account in the confirmation height table std::vector> confirmation_height_infos; auto num = 0u; - for (nano::mdb_iterator i (transaction_a, confirmation_height), n (nano::mdb_iterator{}); i != n; ++i, ++account_info_i, ++num) + for (nano::mdb_iterator i (transaction_a, confirmation_height_handle), n (nano::mdb_iterator{}); i != n; ++i, ++account_info_i, ++num) { nano::account account (i->first); uint64_t confirmation_height (i->second); @@ -491,15 +514,15 @@ void nano::mdb_store::upgrade_v16_to_v17 (nano::write_transaction const & transa } // Clear it then append - auto status (mdb_drop (env.tx (transaction_a), confirmation_height, 0)); - release_assert_success (status); + auto status (mdb_drop (env.tx (transaction_a), confirmation_height_handle, 0)); + release_assert_success (*this, status); for (auto const & confirmation_height_info_pair : confirmation_height_infos) { - mdb_put (env.tx (transaction_a), confirmation_height, nano::mdb_val (confirmation_height_info_pair.first), nano::mdb_val (confirmation_height_info_pair.second), MDB_APPEND); + mdb_put (env.tx (transaction_a), confirmation_height_handle, nano::mdb_val (confirmation_height_info_pair.first), nano::mdb_val (confirmation_height_info_pair.second), MDB_APPEND); } - version_put (transaction_a, 17); + version.put (transaction_a, 17); logger.always_log ("Finished upgrading confirmation height frontiers"); } @@ -507,10 +530,10 @@ void nano::mdb_store::upgrade_v17_to_v18 (nano::write_transaction const & transa { logger.always_log ("Preparing v17 to v18 database upgrade..."); - auto count_pre (count (transaction_a, state_blocks)); + auto count_pre (count (transaction_a, state_blocks_handle)); auto num = 0u; - for (nano::mdb_iterator> state_i (transaction_a, state_blocks), state_n{}; state_i != state_n; ++state_i, ++num) + for (nano::mdb_iterator> state_i (transaction_a, state_blocks_handle), state_n{}; state_i != state_n; ++state_i, ++num) { nano::block_w_sideband_v18 block_w_sideband (state_i->second); auto & block (block_w_sideband.block); @@ -525,7 +548,7 @@ void nano::mdb_store::upgrade_v17_to_v18 (nano::write_transaction const & transa { prev_balance = block_balance_v18 (transaction_a, block->hashables.previous); } - if (block->hashables.balance == prev_balance && network_params.ledger.epochs.is_epoch_link (block->hashables.link)) + if (block->hashables.balance == prev_balance && constants.epochs.is_epoch_link (block->hashables.link)) { is_epoch = true; } @@ -548,7 +571,7 @@ void nano::mdb_store::upgrade_v17_to_v18 (nano::write_transaction const & transa } nano::mdb_val value{ data.size (), (void *)data.data () }; auto s = mdb_cursor_put (state_i.cursor, state_i->first, value, MDB_CURRENT); - release_assert_success (s); + release_assert_success (*this, s); // Every so often output to the log to indicate progress constexpr auto output_cutoff = 1000000; @@ -558,48 +581,48 @@ void nano::mdb_store::upgrade_v17_to_v18 (nano::write_transaction const & transa } } - auto count_post (count (transaction_a, state_blocks)); + auto count_post (count (transaction_a, state_blocks_handle)); release_assert (count_pre == count_post); - version_put (transaction_a, 18); + version.put (transaction_a, 18); logger.always_log ("Finished upgrading the sideband"); } void nano::mdb_store::upgrade_v18_to_v19 (nano::write_transaction const & transaction_a) { logger.always_log ("Preparing v18 to v19 database upgrade..."); - auto count_pre (count (transaction_a, state_blocks) + count (transaction_a, send_blocks) + count (transaction_a, receive_blocks) + count (transaction_a, change_blocks) + count (transaction_a, open_blocks)); + auto count_pre (count (transaction_a, state_blocks_handle) + count (transaction_a, send_blocks_handle) + count (transaction_a, receive_blocks_handle) + count (transaction_a, change_blocks_handle) + count (transaction_a, open_blocks_handle)); // Combine in order of likeliness of counts std::map legacy_open_receive_change_blocks; - for (auto i (nano::store_iterator> (std::make_unique>> (transaction_a, change_blocks))), n (nano::store_iterator> (nullptr)); i != n; ++i) + for (auto i (nano::store_iterator> (std::make_unique>> (transaction_a, change_blocks_handle))), n (nano::store_iterator> (nullptr)); i != n; ++i) { nano::block_sideband_v18 const & old_sideband (i->second.sideband); nano::block_sideband new_sideband (old_sideband.account, old_sideband.successor, old_sideband.balance, old_sideband.height, old_sideband.timestamp, nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0); legacy_open_receive_change_blocks[i->first] = { nano::block_w_sideband{ i->second.block, new_sideband } }; } - for (auto i (nano::store_iterator> (std::make_unique>> (transaction_a, open_blocks))), n (nano::store_iterator> (nullptr)); i != n; ++i) + for (auto i (nano::store_iterator> (std::make_unique>> (transaction_a, open_blocks_handle))), n (nano::store_iterator> (nullptr)); i != n; ++i) { nano::block_sideband_v18 const & old_sideband (i->second.sideband); nano::block_sideband new_sideband (old_sideband.account, old_sideband.successor, old_sideband.balance, old_sideband.height, old_sideband.timestamp, nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0); legacy_open_receive_change_blocks[i->first] = { nano::block_w_sideband{ i->second.block, new_sideband } }; } - for (auto i (nano::store_iterator> (std::make_unique>> (transaction_a, receive_blocks))), n (nano::store_iterator> (nullptr)); i != n; ++i) + for (auto i (nano::store_iterator> (std::make_unique>> (transaction_a, receive_blocks_handle))), n (nano::store_iterator> (nullptr)); i != n; ++i) { nano::block_sideband_v18 const & old_sideband (i->second.sideband); nano::block_sideband new_sideband (old_sideband.account, old_sideband.successor, old_sideband.balance, old_sideband.height, old_sideband.timestamp, nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0); legacy_open_receive_change_blocks[i->first] = { nano::block_w_sideband{ i->second.block, new_sideband } }; } - release_assert (!mdb_drop (env.tx (transaction_a), receive_blocks, 1)); - receive_blocks = 0; - release_assert (!mdb_drop (env.tx (transaction_a), open_blocks, 1)); - open_blocks = 0; - release_assert (!mdb_drop (env.tx (transaction_a), change_blocks, 1)); - change_blocks = 0; + release_assert (!mdb_drop (env.tx (transaction_a), receive_blocks_handle, 1)); + receive_blocks_handle = 0; + release_assert (!mdb_drop (env.tx (transaction_a), open_blocks_handle, 1)); + open_blocks_handle = 0; + release_assert (!mdb_drop (env.tx (transaction_a), change_blocks_handle, 1)); + change_blocks_handle = 0; logger.always_log ("Write legacy open/receive/change to new format"); @@ -618,7 +641,7 @@ void nano::mdb_store::upgrade_v18_to_v19 (nano::write_transaction const & transa nano::mdb_val value{ data.size (), (void *)data.data () }; auto s = mdb_put (env.tx (transaction_a), temp_legacy_open_receive_change_blocks, nano::mdb_val (legacy_block.first), value, MDB_APPEND); - release_assert_success (s); + release_assert_success (*this, s); } } @@ -629,7 +652,7 @@ void nano::mdb_store::upgrade_v18_to_v19 (nano::write_transaction const & transa { mdb_dbi_open (env.tx (transaction_a), "temp_legacy_send_blocks", MDB_CREATE, &temp_legacy_send_blocks); - for (auto i (nano::store_iterator> (std::make_unique>> (transaction_a, send_blocks))), n (nano::store_iterator> (nullptr)); i != n; ++i) + for (auto i (nano::store_iterator> (std::make_unique>> (transaction_a, send_blocks_handle))), n (nano::store_iterator> (nullptr)); i != n; ++i) { auto const & block_w_sideband_v18 (i->second); @@ -642,12 +665,12 @@ void nano::mdb_store::upgrade_v18_to_v19 (nano::write_transaction const & transa nano::mdb_val value{ data.size (), (void *)data.data () }; auto s = mdb_put (env.tx (transaction_a), temp_legacy_send_blocks, nano::mdb_val (i->first), value, MDB_APPEND); - release_assert_success (s); + release_assert_success (*this, s); } } - release_assert (!mdb_drop (env.tx (transaction_a), send_blocks, 1)); - send_blocks = 0; + release_assert (!mdb_drop (env.tx (transaction_a), send_blocks_handle, 1)); + send_blocks_handle = 0; logger.always_log ("Merge legacy open/receive/change with legacy send blocks"); @@ -660,7 +683,7 @@ void nano::mdb_store::upgrade_v18_to_v19 (nano::write_transaction const & transa for (; i != n; ++i) { auto s = mdb_put (env.tx (transaction_a), temp_legacy_send_open_receive_change_blocks, nano::mdb_val (i->first), nano::mdb_val (i->second), MDB_APPEND); - release_assert_success (s); + release_assert_success (*this, s); } // Delete tables @@ -676,7 +699,7 @@ void nano::mdb_store::upgrade_v18_to_v19 (nano::write_transaction const & transa auto type_state (nano::block_type::state); mdb_dbi_open (env.tx (transaction_a), "temp_state_blocks", MDB_CREATE, &temp_state_blocks); - for (auto i (nano::store_iterator> (std::make_unique>> (transaction_a, state_blocks))), n (nano::store_iterator> (nullptr)); i != n; ++i) + for (auto i (nano::store_iterator> (std::make_unique>> (transaction_a, state_blocks_handle))), n (nano::store_iterator> (nullptr)); i != n; ++i) { auto const & block_w_sideband_v18 (i->second); nano::block_sideband_v18 const & old_sideband (block_w_sideband_v18.sideband); @@ -707,53 +730,53 @@ void nano::mdb_store::upgrade_v18_to_v19 (nano::write_transaction const & transa nano::mdb_val value{ data.size (), (void *)data.data () }; auto s = mdb_put (env.tx (transaction_a), temp_state_blocks, nano::mdb_val (i->first), value, MDB_APPEND); - release_assert_success (s); + release_assert_success (*this, s); } } - release_assert (!mdb_drop (env.tx (transaction_a), state_blocks, 1)); - state_blocks = 0; + release_assert (!mdb_drop (env.tx (transaction_a), state_blocks_handle, 1)); + state_blocks_handle = 0; logger.always_log ("Merging all legacy blocks with state blocks"); // Merge all legacy blocks with state blocks into the final table nano::mdb_merge_iterator i (transaction_a, temp_legacy_send_open_receive_change_blocks, temp_state_blocks); nano::mdb_merge_iterator n{}; - mdb_dbi_open (env.tx (transaction_a), "blocks", MDB_CREATE, &blocks); + mdb_dbi_open (env.tx (transaction_a), "blocks", MDB_CREATE, &blocks_handle); for (; i != n; ++i) { - auto s = mdb_put (env.tx (transaction_a), blocks, nano::mdb_val (i->first), nano::mdb_val (i->second), MDB_APPEND); - release_assert_success (s); + auto s = mdb_put (env.tx (transaction_a), blocks_handle, nano::mdb_val (i->first), nano::mdb_val (i->second), MDB_APPEND); + release_assert_success (*this, s); } // Delete tables mdb_drop (env.tx (transaction_a), temp_legacy_send_open_receive_change_blocks, 1); mdb_drop (env.tx (transaction_a), temp_state_blocks, 1); - auto count_post (count (transaction_a, blocks)); + auto count_post (count (transaction_a, blocks_handle)); release_assert (count_pre == count_post); MDB_dbi vote{ 0 }; release_assert (!mdb_dbi_open (env.tx (transaction_a), "vote", MDB_CREATE, &vote)); release_assert (!mdb_drop (env.tx (transaction_a), vote, 1)); - version_put (transaction_a, 19); + version.put (transaction_a, 19); logger.always_log ("Finished upgrading all blocks to new blocks database"); } void nano::mdb_store::upgrade_v19_to_v20 (nano::write_transaction const & transaction_a) { logger.always_log ("Preparing v19 to v20 database upgrade..."); - mdb_dbi_open (env.tx (transaction_a), "pruned", MDB_CREATE, &pruned); - version_put (transaction_a, 20); + mdb_dbi_open (env.tx (transaction_a), "pruned", MDB_CREATE, &pruned_handle); + version.put (transaction_a, 20); logger.always_log ("Finished creating new pruned table"); } void nano::mdb_store::upgrade_v20_to_v21 (nano::write_transaction const & transaction_a) { logger.always_log ("Preparing v20 to v21 database upgrade..."); - mdb_dbi_open (env.tx (transaction_a), "final_votes", MDB_CREATE, &final_votes); - version_put (transaction_a, 21); + mdb_dbi_open (env.tx (transaction_a), "final_votes", MDB_CREATE, &final_votes_handle); + version.put (transaction_a, 21); logger.always_log ("Finished creating new final_vote table"); } @@ -788,10 +811,10 @@ void nano::mdb_store::create_backup_file (nano::mdb_env & env_a, boost::filesyst } } -std::vector nano::mdb_store::unchecked_get (nano::transaction const & transaction_a, nano::block_hash const & hash_a) +std::vector nano::unchecked_mdb_store::get (nano::transaction const & transaction_a, nano::block_hash const & hash_a) { std::vector result; - for (auto i (unchecked_begin (transaction_a, nano::unchecked_key (hash_a, 0))), n (unchecked_end ()); i != n && i->first.key () == hash_a; ++i) + for (auto i (begin (transaction_a, nano::unchecked_key (hash_a, 0))), n (end ()); i != n && i->first.key () == hash_a; ++i) { nano::unchecked_info const & unchecked_info (i->second); result.push_back (unchecked_info); @@ -799,13 +822,8 @@ std::vector nano::mdb_store::unchecked_get (nano::transact return result; } -void nano::mdb_store::version_put (nano::write_transaction const & transaction_a, int version_a) -{ - nano::uint256_union version_key (1); - nano::uint256_union version_value (version_a); - auto status (mdb_put (env.tx (transaction_a), meta, nano::mdb_val (version_key), nano::mdb_val (version_value), 0)); - release_assert_success (status); -} +nano::unchecked_mdb_store::unchecked_mdb_store (nano::mdb_store & mdb_store_a) : + unchecked_store_partial (mdb_store_a){}; bool nano::mdb_store::exists (nano::transaction const & transaction_a, tables table_a, nano::mdb_val const & key_a) const { @@ -820,7 +838,7 @@ int nano::mdb_store::get (nano::transaction const & transaction_a, tables table_ return mdb_get (env.tx (transaction_a), table_to_dbi (table_a), key_a, value_a); } -int nano::mdb_store::put (nano::write_transaction const & transaction_a, tables table_a, nano::mdb_val const & key_a, const nano::mdb_val & value_a) const +int nano::mdb_store::put (nano::write_transaction const & transaction_a, tables table_a, nano::mdb_val const & key_a, nano::mdb_val const & value_a) const { return (mdb_put (env.tx (transaction_a), table_to_dbi (table_a), key_a, value_a, 0)); } @@ -849,7 +867,7 @@ uint64_t nano::mdb_store::count (nano::transaction const & transaction_a, MDB_db { MDB_stat stats; auto status (mdb_stat (env.tx (transaction_a), db_a, &stats)); - release_assert_success (status); + release_assert_success (*this, status); return (stats.ms_entries); } @@ -858,30 +876,30 @@ MDB_dbi nano::mdb_store::table_to_dbi (tables table_a) const switch (table_a) { case tables::frontiers: - return frontiers; + return frontiers_handle; case tables::accounts: - return accounts; + return accounts_handle; case tables::blocks: - return blocks; + return blocks_handle; case tables::pending: - return pending; + return pending_handle; case tables::unchecked: - return unchecked; + return unchecked_handle; case tables::online_weight: - return online_weight; + return online_weight_handle; case tables::meta: - return meta; + return meta_handle; case tables::peers: - return peers; + return peers_handle; case tables::pruned: - return pruned; + return pruned_handle; case tables::confirmation_height: - return confirmation_height; + return confirmation_height_handle; case tables::final_votes: - return final_votes; + return final_votes_handle; default: release_assert (false); - return peers; + return peers_handle; } } @@ -913,7 +931,7 @@ bool nano::mdb_store::copy_db (boost::filesystem::path const & destination_file) void nano::mdb_store::rebuild_db (nano::write_transaction const & transaction_a) { // Tables with uint256_union key - std::vector tables = { accounts, blocks, pruned, confirmation_height }; + std::vector tables = { accounts_handle, blocks_handle, pruned_handle, confirmation_height_handle }; for (auto const & table : tables) { MDB_dbi temp; @@ -922,7 +940,7 @@ void nano::mdb_store::rebuild_db (nano::write_transaction const & transaction_a) for (auto i (nano::store_iterator (std::make_unique> (transaction_a, table))), n (nano::store_iterator (nullptr)); i != n; ++i) { auto s = mdb_put (env.tx (transaction_a), temp, nano::mdb_val (i->first), i->second, MDB_APPEND); - release_assert_success (s); + release_assert_success (*this, s); } release_assert (count (transaction_a, table) == count (transaction_a, temp)); // Clear existing table @@ -931,7 +949,7 @@ void nano::mdb_store::rebuild_db (nano::write_transaction const & transaction_a) for (auto i (nano::store_iterator (std::make_unique> (transaction_a, temp))), n (nano::store_iterator (nullptr)); i != n; ++i) { auto s = mdb_put (env.tx (transaction_a), table, nano::mdb_val (i->first), i->second, MDB_APPEND); - release_assert_success (s); + release_assert_success (*this, s); } release_assert (count (transaction_a, table) == count (transaction_a, temp)); // Remove temporary table @@ -942,20 +960,20 @@ void nano::mdb_store::rebuild_db (nano::write_transaction const & transaction_a) MDB_dbi temp; mdb_dbi_open (env.tx (transaction_a), "temp_table", MDB_CREATE, &temp); // Copy all values to temporary table - for (auto i (nano::store_iterator (std::make_unique> (transaction_a, pending))), n (nano::store_iterator (nullptr)); i != n; ++i) + for (auto i (nano::store_iterator (std::make_unique> (transaction_a, pending_handle))), n (nano::store_iterator (nullptr)); i != n; ++i) { auto s = mdb_put (env.tx (transaction_a), temp, nano::mdb_val (i->first), nano::mdb_val (i->second), MDB_APPEND); - release_assert_success (s); + release_assert_success (*this, s); } - release_assert (count (transaction_a, pending) == count (transaction_a, temp)); - mdb_drop (env.tx (transaction_a), pending, 0); + release_assert (count (transaction_a, pending_handle) == count (transaction_a, temp)); + mdb_drop (env.tx (transaction_a), pending_handle, 0); // Put values from copy for (auto i (nano::store_iterator (std::make_unique> (transaction_a, temp))), n (nano::store_iterator (nullptr)); i != n; ++i) { - auto s = mdb_put (env.tx (transaction_a), pending, nano::mdb_val (i->first), nano::mdb_val (i->second), MDB_APPEND); - release_assert_success (s); + auto s = mdb_put (env.tx (transaction_a), pending_handle, nano::mdb_val (i->first), nano::mdb_val (i->second), MDB_APPEND); + release_assert_success (*this, s); } - release_assert (count (transaction_a, pending) == count (transaction_a, temp)); + release_assert (count (transaction_a, pending_handle) == count (transaction_a, temp)); mdb_drop (env.tx (transaction_a), temp, 1); } } @@ -1011,27 +1029,27 @@ boost::optional nano::mdb_store::block_raw_get_by_type_v18 (nano: { case nano::block_type::send: { - status = mdb_get (env.tx (transaction_a), send_blocks, hash, value); + status = mdb_get (env.tx (transaction_a), send_blocks_handle, hash, value); break; } case nano::block_type::receive: { - status = mdb_get (env.tx (transaction_a), receive_blocks, hash, value); + status = mdb_get (env.tx (transaction_a), receive_blocks_handle, hash, value); break; } case nano::block_type::open: { - status = mdb_get (env.tx (transaction_a), open_blocks, hash, value); + status = mdb_get (env.tx (transaction_a), open_blocks_handle, hash, value); break; } case nano::block_type::change: { - status = mdb_get (env.tx (transaction_a), change_blocks, hash, value); + status = mdb_get (env.tx (transaction_a), change_blocks_handle, hash, value); break; } case nano::block_type::state: { - status = mdb_get (env.tx (transaction_a), state_blocks, hash, value); + status = mdb_get (env.tx (transaction_a), state_blocks_handle, hash, value); break; } case nano::block_type::invalid: @@ -1054,12 +1072,12 @@ nano::uint128_t nano::mdb_store::block_balance_v18 (nano::transaction const & tr { auto block (block_get_v18 (transaction_a, hash_a)); release_assert (block); - nano::uint128_t result (block_balance_calculated (block)); + nano::uint128_t result (this->block.balance_calculated (block)); return result; } // All the v14 functions below are only needed during upgrades -size_t nano::mdb_store::block_successor_offset_v14 (nano::transaction const & transaction_a, size_t entry_size_a, nano::block_type type_a) const +std::size_t nano::mdb_store::block_successor_offset_v14 (nano::transaction const & transaction_a, std::size_t entry_size_a, nano::block_type type_a) const { return entry_size_a - nano::block_sideband_v14::size (type_a); } @@ -1112,34 +1130,34 @@ boost::optional nano::mdb_store::block_raw_get_by_type_v14 (nano: { case nano::block_type::send: { - status = mdb_get (env.tx (transaction_a), send_blocks, hash, value); + status = mdb_get (env.tx (transaction_a), send_blocks_handle, hash, value); break; } case nano::block_type::receive: { - status = mdb_get (env.tx (transaction_a), receive_blocks, hash, value); + status = mdb_get (env.tx (transaction_a), receive_blocks_handle, hash, value); break; } case nano::block_type::open: { - status = mdb_get (env.tx (transaction_a), open_blocks, hash, value); + status = mdb_get (env.tx (transaction_a), open_blocks_handle, hash, value); break; } case nano::block_type::change: { - status = mdb_get (env.tx (transaction_a), change_blocks, hash, value); + status = mdb_get (env.tx (transaction_a), change_blocks_handle, hash, value); break; } case nano::block_type::state: { - status = mdb_get (env.tx (transaction_a), state_blocks_v1, hash, value); + status = mdb_get (env.tx (transaction_a), state_blocks_v1_handle, hash, value); if (is_state_v1 != nullptr) { *is_state_v1 = success (status); } if (not_found (status)) { - status = mdb_get (env.tx (transaction_a), state_blocks_v0, hash, value); + status = mdb_get (env.tx (transaction_a), state_blocks_v0_handle, hash, value); } break; } @@ -1197,4 +1215,4 @@ unsigned nano::mdb_store::max_block_write_batch_num () const } // Explicitly instantiate -template class nano::block_store_partial; +template class nano::store_partial; diff --git a/nano/node/lmdb/lmdb.hpp b/nano/node/lmdb/lmdb.hpp index 70c9fff45d..5b1cf90dc7 100644 --- a/nano/node/lmdb/lmdb.hpp +++ b/nano/node/lmdb/lmdb.hpp @@ -7,8 +7,19 @@ #include #include #include -#include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include @@ -28,23 +39,42 @@ namespace nano using mdb_val = db_val; class logging_mt; +class mdb_store; + +class unchecked_mdb_store : public unchecked_store_partial +{ +public: + explicit unchecked_mdb_store (nano::mdb_store &); + std::vector get (nano::transaction const &, nano::block_hash const &); +}; + /** * mdb implementation of the block store */ -class mdb_store : public block_store_partial +class mdb_store : public store_partial { -public: - using block_store_partial::block_exists; - using block_store_partial::unchecked_put; +private: + nano::block_store_partial block_store_partial; + nano::frontier_store_partial frontier_store_partial; + nano::account_store_partial account_store_partial; + nano::pending_store_partial pending_store_partial; + nano::unchecked_mdb_store unchecked_mdb_store; + nano::online_weight_store_partial online_weight_store_partial; + nano::pruned_store_partial pruned_store_partial; + nano::peer_store_partial peer_store_partial; + nano::confirmation_height_store_partial confirmation_height_store_partial; + nano::final_vote_store_partial final_vote_store_partial; + nano::version_store_partial version_store_partial; + + friend class nano::unchecked_mdb_store; - mdb_store (nano::logger_mt &, boost::filesystem::path const &, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), nano::lmdb_config const & lmdb_config_a = nano::lmdb_config{}, bool backup_before_upgrade = false); +public: + mdb_store (nano::logger_mt &, boost::filesystem::path const &, nano::ledger_constants & constants, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), nano::lmdb_config const & lmdb_config_a = nano::lmdb_config{}, bool backup_before_upgrade = false); nano::write_transaction tx_begin_write (std::vector const & tables_requiring_lock = {}, std::vector const & tables_no_lock = {}) override; nano::read_transaction tx_begin_read () const override; std::string vendor_get () const override; - void version_put (nano::write_transaction const &, int) override; - void serialize_mdb_tracker (boost::property_tree::ptree &, std::chrono::milliseconds, std::chrono::milliseconds) override; static void create_backup_file (nano::mdb_env &, boost::filesystem::path const &, nano::logger_mt &); @@ -64,145 +94,144 @@ class mdb_store : public block_store_partial * Maps head block to owning account * nano::block_hash -> nano::account */ - MDB_dbi frontiers{ 0 }; + MDB_dbi frontiers_handle{ 0 }; /** * Maps account v1 to account information, head, rep, open, balance, timestamp and block count. (Removed) * nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t */ - MDB_dbi accounts_v0{ 0 }; + MDB_dbi accounts_v0_handle{ 0 }; /** * Maps account v0 to account information, head, rep, open, balance, timestamp and block count. (Removed) * nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t */ - MDB_dbi accounts_v1{ 0 }; + MDB_dbi accounts_v1_handle{ 0 }; /** * Maps account v0 to account information, head, rep, open, balance, timestamp, block count and epoch * nano::account -> nano::block_hash, nano::block_hash, nano::block_hash, nano::amount, uint64_t, uint64_t, nano::epoch */ - MDB_dbi accounts{ 0 }; + MDB_dbi accounts_handle{ 0 }; /** * Maps block hash to send block. (Removed) * nano::block_hash -> nano::send_block */ - MDB_dbi send_blocks{ 0 }; + MDB_dbi send_blocks_handle{ 0 }; /** * Maps block hash to receive block. (Removed) * nano::block_hash -> nano::receive_block */ - MDB_dbi receive_blocks{ 0 }; + MDB_dbi receive_blocks_handle{ 0 }; /** * Maps block hash to open block. (Removed) * nano::block_hash -> nano::open_block */ - MDB_dbi open_blocks{ 0 }; + MDB_dbi open_blocks_handle{ 0 }; /** * Maps block hash to change block. (Removed) * nano::block_hash -> nano::change_block */ - MDB_dbi change_blocks{ 0 }; + MDB_dbi change_blocks_handle{ 0 }; /** * Maps block hash to v0 state block. (Removed) * nano::block_hash -> nano::state_block */ - MDB_dbi state_blocks_v0{ 0 }; + MDB_dbi state_blocks_v0_handle{ 0 }; /** * Maps block hash to v1 state block. (Removed) * nano::block_hash -> nano::state_block */ - MDB_dbi state_blocks_v1{ 0 }; + MDB_dbi state_blocks_v1_handle{ 0 }; /** * Maps block hash to state block. (Removed) * nano::block_hash -> nano::state_block */ - MDB_dbi state_blocks{ 0 }; + MDB_dbi state_blocks_handle{ 0 }; /** * Maps min_version 0 (destination account, pending block) to (source account, amount). (Removed) * nano::account, nano::block_hash -> nano::account, nano::amount */ - MDB_dbi pending_v0{ 0 }; + MDB_dbi pending_v0_handle{ 0 }; /** * Maps min_version 1 (destination account, pending block) to (source account, amount). (Removed) * nano::account, nano::block_hash -> nano::account, nano::amount */ - MDB_dbi pending_v1{ 0 }; + MDB_dbi pending_v1_handle{ 0 }; /** * Maps (destination account, pending block) to (source account, amount, version). (Removed) * nano::account, nano::block_hash -> nano::account, nano::amount, nano::epoch */ - MDB_dbi pending{ 0 }; + MDB_dbi pending_handle{ 0 }; /** * Representative weights. (Removed) * nano::account -> nano::uint128_t */ - MDB_dbi representation{ 0 }; + MDB_dbi representation_handle{ 0 }; /** * Unchecked bootstrap blocks info. * nano::block_hash -> nano::unchecked_info */ - MDB_dbi unchecked{ 0 }; + MDB_dbi unchecked_handle{ 0 }; /** * Samples of online vote weight * uint64_t -> nano::amount */ - MDB_dbi online_weight{ 0 }; + MDB_dbi online_weight_handle{ 0 }; /** * Meta information about block store, such as versions. * nano::uint256_union (arbitrary key) -> blob */ - MDB_dbi meta{ 0 }; + MDB_dbi meta_handle{ 0 }; /** * Pruned blocks hashes * nano::block_hash -> none */ - MDB_dbi pruned{ 0 }; + MDB_dbi pruned_handle{ 0 }; /* * Endpoints for peers * nano::endpoint_key -> no_value */ - MDB_dbi peers{ 0 }; + MDB_dbi peers_handle{ 0 }; /* * Confirmation height of an account, and the hash for the block at that height * nano::account -> uint64_t, nano::block_hash */ - MDB_dbi confirmation_height{ 0 }; + MDB_dbi confirmation_height_handle{ 0 }; /* * Contains block_sideband and block for all block types (legacy send/change/open/receive & state blocks) * nano::block_hash -> nano::block_sideband, nano::block */ - MDB_dbi blocks{ 0 }; + MDB_dbi blocks_handle{ 0 }; /** * Maps root to block hash for generated final votes. * nano::qualified_root -> nano::block_hash */ - MDB_dbi final_votes{ 0 }; + MDB_dbi final_votes_handle{ 0 }; bool exists (nano::transaction const & transaction_a, tables table_a, nano::mdb_val const & key_a) const; - std::vector unchecked_get (nano::transaction const & transaction_a, nano::block_hash const & hash_a) override; int get (nano::transaction const & transaction_a, tables table_a, nano::mdb_val const & key_a, nano::mdb_val & value_a) const; - int put (nano::write_transaction const & transaction_a, tables table_a, nano::mdb_val const & key_a, const nano::mdb_val & value_a) const; + int put (nano::write_transaction const & transaction_a, tables table_a, nano::mdb_val const & key_a, nano::mdb_val const & value_a) const; int del (nano::write_transaction const & transaction_a, tables table_a, nano::mdb_val const & key_a) const; bool copy_db (boost::filesystem::path const & destination_file) override; @@ -227,7 +256,7 @@ class mdb_store : public block_store_partial // These are only use in the upgrade process. std::shared_ptr block_get_v14 (nano::transaction const & transaction_a, nano::block_hash const & hash_a, nano::block_sideband_v14 * sideband_a = nullptr, bool * is_state_v1 = nullptr) const; - size_t block_successor_offset_v14 (nano::transaction const & transaction_a, size_t entry_size_a, nano::block_type type_a) const; + std::size_t block_successor_offset_v14 (nano::transaction const & transaction_a, std::size_t entry_size_a, nano::block_type type_a) const; nano::block_hash block_successor_v14 (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const; nano::mdb_val block_raw_get_v14 (nano::transaction const & transaction_a, nano::block_hash const & hash_a, nano::block_type & type_a, bool * is_state_v1 = nullptr) const; boost::optional block_raw_get_by_type_v14 (nano::transaction const & transaction_a, nano::block_hash const & hash_a, nano::block_type & type_a, bool * is_state_v1) const; @@ -282,11 +311,11 @@ class mdb_store : public block_store_partial template <> void * mdb_val::data () const; template <> -size_t mdb_val::size () const; +std::size_t mdb_val::size () const; template <> -mdb_val::db_val (size_t size_a, void * data_a); +mdb_val::db_val (std::size_t size_a, void * data_a); template <> void mdb_val::convert_buffer_to_value (); -extern template class block_store_partial; +extern template class store_partial; } diff --git a/nano/node/lmdb/lmdb_env.hpp b/nano/node/lmdb/lmdb_env.hpp index 139124ce09..6fa3a082d0 100644 --- a/nano/node/lmdb/lmdb_env.hpp +++ b/nano/node/lmdb/lmdb_env.hpp @@ -2,7 +2,7 @@ #include #include -#include +#include namespace nano { @@ -36,7 +36,7 @@ class mdb_env final } /** Used by the wallet to override the config map size */ - options & override_config_map_size (size_t map_size_a) + options & override_config_map_size (std::size_t map_size_a) { config.map_size = map_size_a; return *this; diff --git a/nano/node/lmdb/lmdb_iterator.hpp b/nano/node/lmdb/lmdb_iterator.hpp index 4968d7f2a6..93e2b93961 100644 --- a/nano/node/lmdb/lmdb_iterator.hpp +++ b/nano/node/lmdb/lmdb_iterator.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include #include diff --git a/nano/node/lmdb/lmdb_txn.cpp b/nano/node/lmdb/lmdb_txn.cpp index b5b1645059..97768b898d 100644 --- a/nano/node/lmdb/lmdb_txn.cpp +++ b/nano/node/lmdb/lmdb_txn.cpp @@ -4,7 +4,7 @@ #include #include #include -#include +#include #include @@ -34,7 +34,7 @@ namespace class matches_txn final { public: - explicit matches_txn (const nano::transaction_impl * transaction_impl_a) : + explicit matches_txn (nano::transaction_impl const * transaction_impl_a) : transaction_impl (transaction_impl_a) { } @@ -45,7 +45,7 @@ class matches_txn final } private: - const nano::transaction_impl * transaction_impl; + nano::transaction_impl const * transaction_impl; }; } @@ -149,12 +149,12 @@ void nano::mdb_txn_tracker::serialize_json (boost::property_tree::ptree & json, // Get the time difference now as creating stacktraces (Debug/Windows for instance) can take a while so results won't be as accurate std::vector times_since_start; times_since_start.reserve (copy_stats.size ()); - std::transform (copy_stats.cbegin (), copy_stats.cend (), std::back_inserter (times_since_start), [] (const auto & stat) { + std::transform (copy_stats.cbegin (), copy_stats.cend (), std::back_inserter (times_since_start), [] (auto const & stat) { return stat.timer.since_start (); }); debug_assert (times_since_start.size () == copy_stats.size ()); - for (size_t i = 0; i < times_since_start.size (); ++i) + for (std::size_t i = 0; i < times_since_start.size (); ++i) { auto const & stat = copy_stats[i]; auto time_held_open = times_since_start[i]; @@ -207,7 +207,7 @@ void nano::mdb_txn_tracker::log_if_held_long_enough (nano::mdb_txn_stats const & } } -void nano::mdb_txn_tracker::add (const nano::transaction_impl * transaction_impl) +void nano::mdb_txn_tracker::add (nano::transaction_impl const * transaction_impl) { nano::lock_guard guard (mutex); debug_assert (std::find_if (stats.cbegin (), stats.cend (), matches_txn (transaction_impl)) == stats.cend ()); @@ -215,7 +215,7 @@ void nano::mdb_txn_tracker::add (const nano::transaction_impl * transaction_impl } /** Can be called without error if transaction does not exist */ -void nano::mdb_txn_tracker::erase (const nano::transaction_impl * transaction_impl) +void nano::mdb_txn_tracker::erase (nano::transaction_impl const * transaction_impl) { nano::unique_lock lk (mutex); auto it = std::find_if (stats.begin (), stats.end (), matches_txn (transaction_impl)); @@ -228,7 +228,7 @@ void nano::mdb_txn_tracker::erase (const nano::transaction_impl * transaction_im } } -nano::mdb_txn_stats::mdb_txn_stats (const nano::transaction_impl * transaction_impl) : +nano::mdb_txn_stats::mdb_txn_stats (nano::transaction_impl const * transaction_impl) : transaction_impl (transaction_impl), thread_name (nano::thread_role::get_string ()), stacktrace (std::make_shared ()) @@ -238,5 +238,5 @@ nano::mdb_txn_stats::mdb_txn_stats (const nano::transaction_impl * transaction_i bool nano::mdb_txn_stats::is_write () const { - return (dynamic_cast (transaction_impl) != nullptr); + return (dynamic_cast (transaction_impl) != nullptr); } diff --git a/nano/node/lmdb/lmdb_txn.hpp b/nano/node/lmdb/lmdb_txn.hpp index a4f105044c..6e0a4893ef 100644 --- a/nano/node/lmdb/lmdb_txn.hpp +++ b/nano/node/lmdb/lmdb_txn.hpp @@ -2,7 +2,7 @@ #include #include -#include +#include #include #include @@ -20,8 +20,8 @@ class mdb_env; class mdb_txn_callbacks { public: - std::function txn_start{ [] (const nano::transaction_impl *) {} }; - std::function txn_end{ [] (const nano::transaction_impl *) {} }; + std::function txn_start{ [] (nano::transaction_impl const *) {} }; + std::function txn_end{ [] (nano::transaction_impl const *) {} }; }; class read_mdb_txn final : public read_transaction_impl @@ -54,10 +54,10 @@ class write_mdb_txn final : public write_transaction_impl class mdb_txn_stats { public: - mdb_txn_stats (const nano::transaction_impl * transaction_impl_a); + mdb_txn_stats (nano::transaction_impl const * transaction_impl_a); bool is_write () const; nano::timer timer; - const nano::transaction_impl * transaction_impl; + nano::transaction_impl const * transaction_impl; std::string thread_name; // Smart pointer so that we don't need the full definition which causes min/max issues on Windows @@ -69,8 +69,8 @@ class mdb_txn_tracker public: mdb_txn_tracker (nano::logger_mt & logger_a, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a); void serialize_json (boost::property_tree::ptree & json, std::chrono::milliseconds min_read_time, std::chrono::milliseconds min_write_time); - void add (const nano::transaction_impl * transaction_impl); - void erase (const nano::transaction_impl * transaction_impl); + void add (nano::transaction_impl const * transaction_impl); + void erase (nano::transaction_impl const * transaction_impl); private: nano::mutex mutex; diff --git a/nano/node/lmdb/wallet_value.hpp b/nano/node/lmdb/wallet_value.hpp index 599e8eb582..929ff13d0a 100644 --- a/nano/node/lmdb/wallet_value.hpp +++ b/nano/node/lmdb/wallet_value.hpp @@ -1,7 +1,7 @@ #pragma once #include -#include +#include #include diff --git a/nano/node/logging.cpp b/nano/node/logging.cpp index 23abe8dcb3..5c6b618083 100644 --- a/nano/node/logging.cpp +++ b/nano/node/logging.cpp @@ -36,38 +36,34 @@ void nano::logging::init (boost::filesystem::path const & application_path_a) boost::log::add_console_log (std::cerr, boost::log::keywords::format = format_with_timestamp); } - nano::network_constants network_constants; - if (!network_constants.is_dev_network ()) - { #ifdef BOOST_WINDOWS - if (nano::event_log_reg_entry_exists () || nano::is_windows_elevated ()) - { - static auto event_sink = boost::make_shared> (boost::log::keywords::log_name = "Banano", boost::log::keywords::log_source = "Banano"); - event_sink->set_formatter (format); + if (nano::event_log_reg_entry_exists () || nano::is_windows_elevated ()) + { + static auto event_sink = boost::make_shared> (boost::log::keywords::log_name = "Banano", boost::log::keywords::log_source = "Banano"); + event_sink->set_formatter (format); - // Currently only mapping sys log errors - boost::log::sinks::event_log::custom_event_type_mapping mapping ("Severity"); - mapping[nano::severity_level::error] = boost::log::sinks::event_log::error; - event_sink->locked_backend ()->set_event_type_mapper (mapping); + // Currently only mapping sys log errors + boost::log::sinks::event_log::custom_event_type_mapping mapping ("Severity"); + mapping[nano::severity_level::error] = boost::log::sinks::event_log::error; + event_sink->locked_backend ()->set_event_type_mapper (mapping); - // Only allow messages or error or greater severity to the event log - event_sink->set_filter (severity >= nano::severity_level::error); - boost::log::core::get ()->add_sink (event_sink); - } + // Only allow messages or error or greater severity to the event log + event_sink->set_filter (severity >= nano::severity_level::error); + boost::log::core::get ()->add_sink (event_sink); + } #else - static auto sys_sink = boost::make_shared> (boost::log::keywords::facility = boost::log::sinks::syslog::user, boost::log::keywords::use_impl = boost::log::sinks::syslog::impl_types::native); - sys_sink->set_formatter (format); + static auto sys_sink = boost::make_shared> (boost::log::keywords::facility = boost::log::sinks::syslog::user, boost::log::keywords::use_impl = boost::log::sinks::syslog::impl_types::native); + sys_sink->set_formatter (format); - // Currently only mapping sys log errors - boost::log::sinks::syslog::custom_severity_mapping mapping ("Severity"); - mapping[nano::severity_level::error] = boost::log::sinks::syslog::error; - sys_sink->locked_backend ()->set_severity_mapper (mapping); + // Currently only mapping sys log errors + boost::log::sinks::syslog::custom_severity_mapping mapping ("Severity"); + mapping[nano::severity_level::error] = boost::log::sinks::syslog::error; + sys_sink->locked_backend ()->set_severity_mapper (mapping); - // Only allow messages or error or greater severity to the sys log - sys_sink->set_filter (severity >= nano::severity_level::error); - boost::log::core::get ()->add_sink (sys_sink); + // Only allow messages or error or greater severity to the sys log + sys_sink->set_filter (severity >= nano::severity_level::error); + boost::log::core::get ()->add_sink (sys_sink); #endif - } //clang-format off #if BOOST_VERSION < 107000 @@ -150,6 +146,7 @@ nano::error nano::logging::serialize_toml (nano::tomlconfig & toml) const toml.put ("ledger_duplicate", ledger_duplicate_logging_value, "Log when a duplicate block is attempted inserted into the ledger.\ntype:bool"); toml.put ("ledger_rollback", election_fork_tally_logging_value, "Log when a block is replaced in the ledger.\ntype:bool"); toml.put ("vote", vote_logging_value, "Vote logging. Enabling this option leads to a high volume.\nof log messages which may affect node performance.\ntype:bool"); + toml.put ("rep_crawler", rep_crawler_logging_value, "Rep crawler logging. Enabling this option leads to a high volume.\nof log messages which may affect node performance.\ntype:bool"); toml.put ("election_expiration", election_expiration_tally_logging_value, "Log election tally on expiration.\ntype:bool"); toml.put ("election_fork", election_fork_tally_logging_value, "Log election tally when more than one block is seen.\ntype:bool"); toml.put ("network", network_logging_value, "Log network related messages.\ntype:bool"); @@ -186,6 +183,7 @@ nano::error nano::logging::deserialize_toml (nano::tomlconfig & toml) toml.get ("ledger_duplicate", ledger_duplicate_logging_value); toml.get ("ledger_rollback", ledger_rollback_logging_value); toml.get ("vote", vote_logging_value); + toml.get ("rep_crawler", rep_crawler_logging_value); toml.get ("election_expiration", election_expiration_tally_logging_value); toml.get ("election_fork", election_fork_tally_logging_value); toml.get ("network", network_logging_value); @@ -224,6 +222,7 @@ nano::error nano::logging::serialize_json (nano::jsonconfig & json) const json.put ("ledger", ledger_logging_value); json.put ("ledger_duplicate", ledger_duplicate_logging_value); json.put ("vote", vote_logging_value); + json.put ("rep_crawler", rep_crawler_logging_value); json.put ("network", network_logging_value); json.put ("network_timeout", network_timeout_logging_value); json.put ("network_message", network_message_logging_value); @@ -280,6 +279,7 @@ nano::error nano::logging::deserialize_json (bool & upgraded_a, nano::jsonconfig json.get ("ledger", ledger_logging_value); json.get ("ledger_duplicate", ledger_duplicate_logging_value); json.get ("vote", vote_logging_value); + json.get ("rep_crawler", rep_crawler_logging_value); json.get ("network", network_logging_value); json.get ("network_timeout", network_timeout_logging_value); json.get ("network_message", network_message_logging_value); @@ -325,6 +325,11 @@ bool nano::logging::vote_logging () const return vote_logging_value; } +bool nano::logging::rep_crawler_logging () const +{ + return rep_crawler_logging_value; +} + bool nano::logging::election_expiration_tally_logging () const { return election_expiration_tally_logging_value; diff --git a/nano/node/logging.hpp b/nano/node/logging.hpp index a347fb52d4..1692195ad9 100644 --- a/nano/node/logging.hpp +++ b/nano/node/logging.hpp @@ -46,6 +46,7 @@ class logging final bool ledger_duplicate_logging () const; bool ledger_rollback_logging () const; bool vote_logging () const; + bool rep_crawler_logging () const; bool election_fork_tally_logging () const; bool election_expiration_tally_logging () const; bool network_logging () const; @@ -74,6 +75,7 @@ class logging final bool ledger_duplicate_logging_value{ false }; bool ledger_rollback_logging_value{ false }; bool vote_logging_value{ false }; + bool rep_crawler_logging_value{ false }; bool election_fork_tally_logging_value{ false }; bool election_expiration_tally_logging_value{ false }; bool network_logging_value{ true }; diff --git a/nano/node/network.cpp b/nano/node/network.cpp index 60ae608d6a..0b2ed57909 100644 --- a/nano/node/network.cpp +++ b/nano/node/network.cpp @@ -12,22 +12,33 @@ #include nano::network::network (nano::node & node_a, uint16_t port_a) : - syn_cookies (node_a.network_params.node.max_peers_per_ip), + id (nano::network_constants::active_network), + syn_cookies (node_a.network_params.network.max_peers_per_ip), + inbound{ [this] (nano::message const & message, std::shared_ptr const & channel) { + if (message.header.network == id) + { + process_message (message, channel); + } + else + { + this->node.stats.inc (nano::stat::type::message, nano::stat::detail::invalid_network); + } + } }, buffer_container (node_a.stats, nano::network::buffer_size, 4096), // 2Mb receive buffer resolver (node_a.io_ctx), limiter (node_a.config.bandwidth_limit_burst_ratio, node_a.config.bandwidth_limit), tcp_message_manager (node_a.config.tcp_incoming_connections_max), node (node_a), publish_filter (256 * 1024), - udp_channels (node_a, port_a), - tcp_channels (node_a), + udp_channels (node_a, port_a, inbound), + tcp_channels (node_a, inbound), port (port_a), disconnect_observer ([] () {}) { boost::thread::attributes attrs; nano::thread_attributes::set (attrs); // UDP - for (size_t i = 0; i < node.config.network_threads && !node.flags.disable_udp; ++i) + for (std::size_t i = 0; i < node.config.network_threads && !node.flags.disable_udp; ++i) { packet_processing_threads.emplace_back (attrs, [this] () { nano::thread_role::set (nano::thread_role::name::packet_processing); @@ -62,7 +73,7 @@ nano::network::network (nano::node & node_a, uint16_t port_a) : }); } // TCP - for (size_t i = 0; i < node.config.network_threads && !node.flags.disable_tcp_realtime; ++i) + for (std::size_t i = 0; i < node.config.network_threads && !node.flags.disable_tcp_realtime; ++i) { packet_processing_threads.emplace_back (attrs, [this] () { nano::thread_role::set (nano::thread_role::name::packet_processing); @@ -105,7 +116,10 @@ nano::network::~network () void nano::network::start () { - ongoing_cleanup (); + if (!node.flags.disable_connection_cleanup) + { + ongoing_cleanup (); + } ongoing_syn_cookie_cleanup (); if (!node.flags.disable_udp) { @@ -138,14 +152,14 @@ void nano::network::stop () void nano::network::send_keepalive (std::shared_ptr const & channel_a) { - nano::keepalive message; + nano::keepalive message{ node.network_params.network }; random_fill (message.peers); channel_a->send (message); } void nano::network::send_keepalive_self (std::shared_ptr const & channel_a) { - nano::keepalive message; + nano::keepalive message{ node.network_params.network }; fill_keepalive_self (message.peers); channel_a->send (message); } @@ -158,7 +172,7 @@ void nano::network::send_node_id_handshake (std::shared_ptrfirst, *respond_to, response->second)); } - nano::node_id_handshake message (query, response); + nano::node_id_handshake message{ node.network_params.network, query, response }; if (node.config.logging.network_node_id_handshake_logging ()) { node.logger.try_log (boost::str (boost::format ("Node ID handshake sent with node ID %1% to %2%: query %3%, respond_to %4% (signature %5%)") % node.node_id.pub.to_node_id () % channel_a->get_endpoint () % (query ? query->to_string () : std::string ("[none]")) % (respond_to ? respond_to->to_string () : std::string ("[none]")) % (response ? response->second.to_string () : std::string ("[none]")))); @@ -166,7 +180,7 @@ void nano::network::send_node_id_handshake (std::shared_ptrsend (message); } -void nano::network::flood_message (nano::message const & message_a, nano::buffer_drop_policy const drop_policy_a, float const scale_a) +void nano::network::flood_message (nano::message & message_a, nano::buffer_drop_policy const drop_policy_a, float const scale_a) { for (auto & i : list (fanout (scale_a))) { @@ -174,15 +188,29 @@ void nano::network::flood_message (nano::message const & message_a, nano::buffer } } +void nano::network::flood_keepalive (float const scale_a) +{ + nano::keepalive message{ node.network_params.network }; + random_fill (message.peers); + flood_message (message, nano::buffer_drop_policy::limiter, scale_a); +} + +void nano::network::flood_keepalive_self (float const scale_a) +{ + nano::keepalive message{ node.network_params.network }; + fill_keepalive_self (message.peers); + flood_message (message, nano::buffer_drop_policy::limiter, scale_a); +} + void nano::network::flood_block (std::shared_ptr const & block_a, nano::buffer_drop_policy const drop_policy_a) { - nano::publish message (block_a); + nano::publish message (node.network_params.network, block_a); flood_message (message, drop_policy_a); } void nano::network::flood_block_initial (std::shared_ptr const & block_a) { - nano::publish message (block_a); + nano::publish message (node.network_params.network, block_a); for (auto const & i : node.rep_crawler.principal_representatives ()) { i.channel->send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop); @@ -195,7 +223,7 @@ void nano::network::flood_block_initial (std::shared_ptr const & bl void nano::network::flood_vote (std::shared_ptr const & vote_a, float scale) { - nano::confirm_ack message (vote_a); + nano::confirm_ack message{ node.network_params.network, vote_a }; for (auto & i : list (fanout (scale))) { i->send (message, nullptr); @@ -204,7 +232,7 @@ void nano::network::flood_vote (std::shared_ptr const & vote_a, floa void nano::network::flood_vote_pr (std::shared_ptr const & vote_a) { - nano::confirm_ack message (vote_a); + nano::confirm_ack message{ node.network_params.network, vote_a }; for (auto const & i : node.rep_crawler.principal_representatives ()) { i.channel->send (message, nullptr, nano::buffer_drop_policy::no_limiter_drop); @@ -238,17 +266,17 @@ void nano::network::flood_block_many (std::deque> b void nano::network::send_confirm_req (std::shared_ptr const & channel_a, std::pair const & hash_root_a) { // Confirmation request with hash + root - nano::confirm_req req (hash_root_a.first, hash_root_a.second); + nano::confirm_req req (node.network_params.network, hash_root_a.first, hash_root_a.second); channel_a->send (req); } void nano::network::broadcast_confirm_req (std::shared_ptr const & block_a) { - auto list (std::make_shared>> (node.rep_crawler.representative_endpoints (std::numeric_limits::max ()))); + auto list (std::make_shared>> (node.rep_crawler.representative_endpoints (std::numeric_limits::max ()))); if (list->empty () || node.rep_crawler.total_weight () < node.online_reps.delta ()) { // broadcast request to all peers (with max limit 2 * sqrt (peers count)) - auto peers (node.network.list (std::min (100, node.network.fanout (2.0)))); + auto peers (node.network.list (std::min (100, node.network.fanout (2.0)))); list->clear (); list->insert (list->end (), peers.begin (), peers.end ()); } @@ -260,7 +288,7 @@ void nano::network::broadcast_confirm_req (std::shared_ptr const & * of "broadcast_confirm_req" will be responsible for calling it again * if the votes for a block have not arrived in time. */ - const size_t max_endpoints = 32; + std::size_t const max_endpoints = 32; nano::random_pool_shuffle (list->begin (), list->end ()); if (list->size () > max_endpoints) { @@ -272,7 +300,7 @@ void nano::network::broadcast_confirm_req (std::shared_ptr const & void nano::network::broadcast_confirm_req_base (std::shared_ptr const & block_a, std::shared_ptr>> const & endpoints_a, unsigned delay_a, bool resumption) { - const size_t max_reps = 10; + std::size_t const max_reps = 10; if (!resumption && node.config.logging.network_logging ()) { node.logger.try_log (boost::str (boost::format ("Broadcasting confirm req for block %1% to %2% representatives") % block_a->hash ().to_string () % endpoints_a->size ())); @@ -316,7 +344,7 @@ void nano::network::broadcast_confirm_req_batched_many (std::unordered_mapsecond.front ()); i->second.pop_front (); } - nano::confirm_req req (roots_hashes_l); + nano::confirm_req req{ node.network_params.network, roots_hashes_l }; i->first->send (req); if (i->second.empty ()) { @@ -446,7 +474,7 @@ class network_message_visitor : public nano::message_visitor { if (node.config.logging.network_message_logging ()) { - node.logger.try_log (boost::str (boost::format ("Received confirm_ack message from %1% for %2% timestamp %3%") % channel->to_string () % message_a.vote->hashes_string () % std::to_string (message_a.vote->timestamp))); + node.logger.try_log (boost::str (boost::format ("Received confirm_ack message from %1% for %2% timestamp %3%") % channel->to_string () % message_a.vote->hashes_string () % std::to_string (message_a.vote->timestamp ()))); } node.stats.inc (nano::stat::type::message, nano::stat::detail::confirm_ack, nano::stat::dir::in); if (!message_a.vote->account.is_zero ()) @@ -502,11 +530,11 @@ class network_message_visitor : public nano::message_visitor // Send an empty telemetry_ack if we do not want, just to acknowledge that we have received the message to // remove any timeouts on the server side waiting for a message. - nano::telemetry_ack telemetry_ack; + nano::telemetry_ack telemetry_ack{ node.network_params.network }; if (!node.flags.disable_providing_telemetry_metrics) { auto telemetry_data = nano::local_telemetry_data (node.ledger, node.network, node.config.bandwidth_limit, node.network_params, node.startup_time, node.default_difficulty (nano::work_version::work_1), node.node_id); - telemetry_ack = nano::telemetry_ack (telemetry_data); + telemetry_ack = nano::telemetry_ack{ node.network_params.network, telemetry_data }; } channel->send (telemetry_ack, nullptr, nano::buffer_drop_policy::no_socket_drop); } @@ -547,12 +575,7 @@ void nano::network::merge_peer (nano::endpoint const & peer_a) if (!reachout (peer_a, node.config.allow_local_peers)) { std::weak_ptr node_w (node.shared ()); - node.network.tcp_channels.start_tcp (peer_a, [node_w] (std::shared_ptr const & channel_a) { - if (auto node_l = node_w.lock ()) - { - node_l->network.send_keepalive (channel_a); - } - }); + node.network.tcp_channels.start_tcp (peer_a); } } @@ -586,7 +609,7 @@ bool nano::network::reachout (nano::endpoint const & endpoint_a, bool allow_loca return error; } -std::deque> nano::network::list (size_t count_a, uint8_t minimum_version_a, bool include_tcp_temporary_channels_a) +std::deque> nano::network::list (std::size_t count_a, uint8_t minimum_version_a, bool include_tcp_temporary_channels_a) { std::deque> result; tcp_channels.list (result, minimum_version_a, include_tcp_temporary_channels_a); @@ -599,7 +622,7 @@ std::deque> nano::network::list (size_ return result; } -std::deque> nano::network::list_non_pr (size_t count_a) +std::deque> nano::network::list_non_pr (std::size_t count_a) { std::deque> result; tcp_channels.list (result); @@ -617,12 +640,12 @@ std::deque> nano::network::list_non_pr } // 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 -size_t nano::network::fanout (float scale) const +std::size_t nano::network::fanout (float scale) const { - return static_cast (std::ceil (scale * size_sqrt ())); + return static_cast (std::ceil (scale * size_sqrt ())); } -std::unordered_set> nano::network::random_set (size_t count_a, uint8_t min_version_a, bool include_temporary_channels_a) const +std::unordered_set> nano::network::random_set (std::size_t count_a, uint8_t min_version_a, bool include_temporary_channels_a) const { std::unordered_set> result (tcp_channels.random_set (count_a, min_version_a, include_temporary_channels_a)); std::unordered_set> udp_random (udp_channels.random_set (count_a, min_version_a)); @@ -656,6 +679,10 @@ void nano::network::random_fill (std::array & target_a) const void nano::network::fill_keepalive_self (std::array & target_a) const { random_fill (target_a); + // We will clobber values in index 0 and 1 and if there are only 2 nodes in the system, these are the only positions occupied + // Move these items to index 2 and 3 so they propagate + target_a[2] = target_a[0]; + target_a[3] = target_a[1]; // Replace part of message with node external address or listening port target_a[1] = nano::endpoint (boost::asio::ip::address_v6{}, 0); // For node v19 (response channels) if (node.config.external_address != boost::asio::ip::address_v6{}.to_string () && node.config.external_port != 0) @@ -685,11 +712,11 @@ nano::tcp_endpoint nano::network::bootstrap_peer (bool lazy_bootstrap) bool use_udp_peer (nano::random_pool::generate_word32 (0, 1)); if (use_udp_peer || tcp_channels.size () == 0) { - result = udp_channels.bootstrap_peer (node.network_params.protocol.protocol_version_min ()); + result = udp_channels.bootstrap_peer (node.network_params.network.protocol_version_min); } if (result == nano::tcp_endpoint (boost::asio::ip::address_v6::any (), 0)) { - result = tcp_channels.bootstrap_peer (node.network_params.protocol.protocol_version_min ()); + result = tcp_channels.bootstrap_peer (node.network_params.network.protocol_version_min); } return result; } @@ -731,9 +758,9 @@ void nano::network::cleanup (std::chrono::steady_clock::time_point const & cutof void nano::network::ongoing_cleanup () { - cleanup (std::chrono::steady_clock::now () - node.network_params.node.cutoff); + cleanup (std::chrono::steady_clock::now () - node.network_params.network.cleanup_cutoff ()); std::weak_ptr node_w (node.shared ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.period, [node_w] () { + node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.network.cleanup_period, [node_w] () { if (auto node_l = node_w.lock ()) { node_l->network.ongoing_cleanup (); @@ -758,7 +785,7 @@ void nano::network::ongoing_keepalive () flood_keepalive (0.75f); flood_keepalive_self (0.25f); std::weak_ptr node_w (node.shared ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.half_period, [node_w] () { + node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.network.cleanup_period_half (), [node_w] () { if (auto node_l = node_w.lock ()) { node_l->network.ongoing_keepalive (); @@ -766,7 +793,7 @@ void nano::network::ongoing_keepalive () }); } -size_t nano::network::size () const +std::size_t nano::network::size () const { return tcp_channels.size () + udp_channels.size (); } @@ -795,12 +822,12 @@ void nano::network::erase (nano::transport::channel const & channel_a) } } -void nano::network::set_bandwidth_params (double limit_burst_ratio_a, size_t limit_a) +void nano::network::set_bandwidth_params (double limit_burst_ratio_a, std::size_t limit_a) { limiter.reset (limit_burst_ratio_a, limit_a); } -nano::message_buffer_manager::message_buffer_manager (nano::stat & stats_a, size_t size, size_t count) : +nano::message_buffer_manager::message_buffer_manager (nano::stat & stats_a, std::size_t size, std::size_t count) : stats (stats_a), free (count), full (count), @@ -922,7 +949,7 @@ nano::tcp_message_item nano::tcp_message_manager::get_message () } else { - result = nano::tcp_message_item{ std::make_shared (), nano::tcp_endpoint (boost::asio::ip::address_v6::any (), 0), 0, nullptr, nano::bootstrap_server_type::undefined }; + result = nano::tcp_message_item{ nullptr, nano::tcp_endpoint (boost::asio::ip::address_v6::any (), 0), 0, nullptr }; } lock.unlock (); producer_condition.notify_one (); @@ -939,7 +966,7 @@ void nano::tcp_message_manager::stop () producer_condition.notify_all (); } -nano::syn_cookies::syn_cookies (size_t max_cookies_per_ip_a) : +nano::syn_cookies::syn_cookies (std::size_t max_cookies_per_ip_a) : max_cookies_per_ip (max_cookies_per_ip_a) { } @@ -1017,7 +1044,7 @@ void nano::syn_cookies::purge (std::chrono::steady_clock::time_point const & cut } } -size_t nano::syn_cookies::cookies_size () +std::size_t nano::syn_cookies::cookies_size () { nano::lock_guard lock (syn_cookie_mutex); return cookies.size (); @@ -1035,8 +1062,8 @@ std::unique_ptr nano::collect_container_info (ne std::unique_ptr nano::syn_cookies::collect_container_info (std::string const & name) { - size_t syn_cookies_count; - size_t syn_cookies_per_ip_count; + std::size_t syn_cookies_count; + std::size_t syn_cookies_per_ip_count; { nano::lock_guard syn_cookie_guard (syn_cookie_mutex); syn_cookies_count = cookies.size (); diff --git a/nano/node/network.hpp b/nano/node/network.hpp index 6ebd1a65eb..43f510ad06 100644 --- a/nano/node/network.hpp +++ b/nano/node/network.hpp @@ -21,7 +21,7 @@ class message_buffer final { public: uint8_t * buffer{ nullptr }; - size_t size{ 0 }; + std::size_t size{ 0 }; nano::endpoint endpoint; }; /** @@ -38,7 +38,7 @@ class message_buffer_manager final // Stats - Statistics // Size - Size of each individual buffer // Count - Number of buffers to allocate - message_buffer_manager (nano::stat & stats, size_t, size_t); + message_buffer_manager (nano::stat & stats, std::size_t, std::size_t); // Return a buffer where message 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 @@ -92,7 +92,7 @@ class tcp_message_manager final class syn_cookies final { public: - syn_cookies (size_t); + syn_cookies (std::size_t); void purge (std::chrono::steady_clock::time_point const &); // Returns boost::none if the IP is rate capped on syn cookie requests, // or if the endpoint already has a syn cookie query @@ -101,7 +101,7 @@ class syn_cookies final // Also removes the syn cookie from the store if valid bool validate (nano::endpoint const &, nano::account const &, nano::signature const &); std::unique_ptr collect_container_info (std::string const &); - size_t cookies_size (); + std::size_t cookies_size (); private: class syn_cookie_info final @@ -113,28 +113,19 @@ class syn_cookies final mutable nano::mutex syn_cookie_mutex; std::unordered_map cookies; std::unordered_map cookies_per_ip; - size_t max_cookies_per_ip; + std::size_t max_cookies_per_ip; }; class network final { public: network (nano::node &, uint16_t); ~network (); + nano::networks id; void start (); void stop (); - void flood_message (nano::message const &, nano::buffer_drop_policy const = nano::buffer_drop_policy::limiter, float const = 1.0f); - void flood_keepalive (float const scale_a = 1.0f) - { - nano::keepalive message; - random_fill (message.peers); - flood_message (message, nano::buffer_drop_policy::limiter, scale_a); - } - void flood_keepalive_self (float const scale_a = 0.5f) - { - nano::keepalive message; - fill_keepalive_self (message.peers); - flood_message (message, nano::buffer_drop_policy::limiter, scale_a); - } + void flood_message (nano::message &, nano::buffer_drop_policy const = nano::buffer_drop_policy::limiter, float const = 1.0f); + void flood_keepalive (float const scale_a = 1.0f); + void flood_keepalive_self (float const scale_a = 0.5f); void flood_vote (std::shared_ptr const &, float scale); void flood_vote_pr (std::shared_ptr const &); // Flood block to all PRs and a random selection of non-PRs @@ -154,18 +145,17 @@ class network final void broadcast_confirm_req_many (std::deque, std::shared_ptr>>>>, std::function = nullptr, unsigned = broadcast_interval_ms); std::shared_ptr find_node_id (nano::account const &); std::shared_ptr find_channel (nano::endpoint const &); - void process_message (nano::message const &, std::shared_ptr const &); bool not_a_peer (nano::endpoint const &, bool); // Should we reach out to this endpoint with a keepalive message bool reachout (nano::endpoint const &, bool = false); - std::deque> list (size_t, uint8_t = 0, bool = true); - std::deque> list_non_pr (size_t); + std::deque> list (std::size_t, uint8_t = 0, bool = true); + std::deque> list_non_pr (std::size_t); // Desired fanout for a given scale - size_t fanout (float scale = 1.0f) const; + std::size_t fanout (float scale = 1.0f) const; void random_fill (std::array &) const; void fill_keepalive_self (std::array &) const; // Note: The minimum protocol version is used after the random selection, so number of peers can be less than expected. - std::unordered_set> random_set (size_t, uint8_t = 0, bool = false) const; + std::unordered_set> random_set (std::size_t, uint8_t = 0, bool = false) const; // Get the next peer for attempting a tcp bootstrap connection nano::tcp_endpoint bootstrap_peer (bool = false); nano::endpoint endpoint (); @@ -175,11 +165,17 @@ class network final nano::syn_cookies syn_cookies; void ongoing_syn_cookie_cleanup (); void ongoing_keepalive (); - size_t size () const; + std::size_t size () const; float size_sqrt () const; bool empty () const; void erase (nano::transport::channel const &); - void set_bandwidth_params (double, size_t); + void set_bandwidth_params (double, std::size_t); + +private: + void process_message (nano::message const &, std::shared_ptr const &); + +public: + std::function const &)> inbound; nano::message_buffer_manager buffer_container; boost::asio::ip::udp::resolver resolver; std::vector packet_processing_threads; @@ -196,9 +192,9 @@ class network final std::function)> channel_observer; std::atomic stopped{ false }; static unsigned const broadcast_interval_ms = 10; - static size_t const buffer_size = 512; - static size_t const confirm_req_hashes_max = 7; - static size_t const confirm_ack_hashes_max = 12; + static std::size_t const buffer_size = 512; + static std::size_t const confirm_req_hashes_max = 7; + static std::size_t const confirm_ack_hashes_max = 12; }; std::unique_ptr collect_container_info (network & network, std::string const & name); } diff --git a/nano/node/node.cpp b/nano/node/node.cpp index 502d97d872..ef1305fc0b 100644 --- a/nano/node/node.cpp +++ b/nano/node/node.cpp @@ -1,3 +1,4 @@ +#include #include #include #include @@ -6,10 +7,10 @@ #include #include #include -#include #include #include #include +#include #include #include @@ -21,15 +22,15 @@ double constexpr nano::node::price_max; double constexpr nano::node::free_cutoff; -size_t constexpr nano::block_arrival::arrival_size_min; +std::size_t constexpr nano::block_arrival::arrival_size_min; std::chrono::seconds constexpr nano::block_arrival::arrival_time_min; namespace nano { extern unsigned char nano_bootstrap_weights_live[]; -extern size_t nano_bootstrap_weights_live_size; +extern std::size_t nano_bootstrap_weights_live_size; extern unsigned char nano_bootstrap_weights_beta[]; -extern size_t nano_bootstrap_weights_beta_size; +extern std::size_t nano_bootstrap_weights_beta_size; } void nano::node::keepalive (std::string const & address_a, uint16_t port_a) @@ -45,12 +46,7 @@ void nano::node::keepalive (std::string const & address_a, uint16_t port_a) auto channel (node_l->network.find_channel (endpoint)); if (!channel) { - node_l->network.tcp_channels.start_tcp (endpoint, [node_w] (std::shared_ptr const & channel_a) { - if (auto node_l = node_w.lock ()) - { - node_l->network.send_keepalive (channel_a); - } - }); + node_l->network.tcp_channels.start_tcp (endpoint); } else { @@ -67,13 +63,13 @@ void nano::node::keepalive (std::string const & address_a, uint16_t port_a) std::unique_ptr nano::collect_container_info (rep_crawler & rep_crawler, std::string const & name) { - size_t count; + std::size_t count; { nano::lock_guard guard (rep_crawler.active_mutex); count = rep_crawler.active.size (); } - auto sizeof_element = sizeof (decltype (rep_crawler.active)::value_type); + auto const sizeof_element = sizeof (decltype (rep_crawler.active)::value_type); auto composite = std::make_unique (name); composite->add_component (std::make_unique (container_info{ "active", count, sizeof_element })); return composite; @@ -85,22 +81,23 @@ nano::node::node (boost::asio::io_context & io_ctx_a, uint16_t peering_port_a, b } nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path const & application_path_a, nano::node_config const & config_a, nano::work_pool & work_a, nano::node_flags flags_a, unsigned seq) : - write_database_queue (!flags_a.force_use_write_database_queue && (config_a.rocksdb_config.enable || nano::using_rocksdb_in_tests ())), + write_database_queue (!flags_a.force_use_write_database_queue && (config_a.rocksdb_config.enable)), io_ctx (io_ctx_a), node_initialized_latch (1), config (config_a), + network_params{ config.network_params }, stats (config.stat_config), workers (std::max (3u, config.io_threads / 4), nano::thread_role::name::worker), flags (flags_a), work (work_a), distributed_work (*this), logger (config_a.logging.min_time_between_log_output), - store_impl (nano::make_store (logger, application_path_a, flags.read_only, true, config_a.rocksdb_config, config_a.diagnostics_config.txn_tracking, config_a.block_processor_batch_max_time, config_a.lmdb_config, config_a.backup_before_upgrade)), + store_impl (nano::make_store (logger, application_path_a, network_params.ledger, flags.read_only, true, config_a.rocksdb_config, config_a.diagnostics_config.txn_tracking, config_a.block_processor_batch_max_time, config_a.lmdb_config, config_a.backup_before_upgrade)), store (*store_impl), wallets_store_impl (std::make_unique (application_path_a / "wallets.ldb", config_a.lmdb_config)), wallets_store (*wallets_store_impl), gap_cache (*this), - ledger (store, stats, flags_a.generate_cache), + ledger (store, stats, network_params.ledger, flags_a.generate_cache), checker (config.signature_checker_threads), network (*this, config.peering_port), telemetry (std::make_shared (network, workers, observers.telemetry, stats, network_params, flags.disable_ongoing_telemetry_requests)), @@ -118,7 +115,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co confirmation_height_processor (ledger, write_database_queue, config.conf_height_processor_batch_min_time, config.logging, logger, node_initialized_latch, flags.confirmation_height_processor_mode), active (*this, confirmation_height_processor), scheduler{ *this }, - aggregator (network_params.network, config, stats, active.generator, active.final_generator, history, ledger, wallets, active), + aggregator (config, stats, active.generator, active.final_generator, history, ledger, wallets, active), wallets (wallets_store.init_error (), *this), startup_time (std::chrono::steady_clock::now ()), node_seq (seq) @@ -132,7 +129,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co if (config.websocket_config.enabled) { auto endpoint_l (nano::tcp_endpoint (boost::asio::ip::make_address_v6 (config.websocket_config.address), config.websocket_config.port)); - websocket_server = std::make_shared (logger, wallets, io_ctx, endpoint_l); + websocket_server = std::make_shared (config.websocket_config.tls_config, logger, wallets, io_ctx, endpoint_l); this->websocket_server->run (); } @@ -148,12 +145,12 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co }; if (!config.callback_address.empty ()) { - observers.blocks.add ([this] (nano::election_status const & status_a, std::vector const & votes_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a) { + observers.blocks.add ([this] (nano::election_status const & status_a, std::vector const & votes_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a, bool is_state_epoch_a) { auto block_a (status_a.winner); if ((status_a.type == nano::election_status_type::active_confirmed_quorum || status_a.type == nano::election_status_type::active_confirmation_height) && this->block_arrival.recent (block_a->hash ())) { auto node_l (shared_from_this ()); - background ([node_l, block_a, account_a, amount_a, is_state_send_a] () { + background ([node_l, block_a, account_a, amount_a, is_state_send_a, is_state_epoch_a] () { boost::property_tree::ptree event; event.add ("account", account_a.to_account ()); event.add ("hash", block_a->hash ().to_string ()); @@ -161,6 +158,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co block_a->serialize_json (block_text); event.add ("block", block_text); event.add ("amount", amount_a.to_string_dec ()); + event.add ("amount_decimal", convert_raw_to_dec (amount_a.to_string_dec ())); if (is_state_send_a) { event.add ("is_send", is_state_send_a); @@ -173,8 +171,9 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co { event.add ("subtype", "change"); } - else if (amount_a == 0 && node_l->ledger.is_epoch_link (block_a->link ())) + else if (is_state_epoch_a) { + debug_assert (amount_a == 0 && node_l->ledger.is_epoch_link (block_a->link ())); event.add ("subtype", "epoch"); } else @@ -210,7 +209,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co } if (websocket_server) { - observers.blocks.add ([this] (nano::election_status const & status_a, std::vector const & votes_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a) { + observers.blocks.add ([this] (nano::election_status const & status_a, std::vector const & votes_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a, bool is_state_epoch_a) { debug_assert (status_a.type != nano::election_status_type::ongoing); if (this->websocket_server->any_subscriber (nano::websocket::topic::confirmation)) @@ -227,8 +226,9 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co { subtype = "change"; } - else if (amount_a == 0 && this->ledger.is_epoch_link (block_a->link ())) + else if (is_state_epoch_a) { + debug_assert (amount_a == 0 && this->ledger.is_epoch_link (block_a->link ())); subtype = "epoch"; } else @@ -258,7 +258,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co }); } // Add block confirmation type stats regardless of http-callback and websocket subscriptions - observers.blocks.add ([this] (nano::election_status const & status_a, std::vector const & votes_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a) { + observers.blocks.add ([this] (nano::election_status const & status_a, std::vector const & votes_a, nano::account const & account_a, nano::amount const & amount_a, bool is_state_send_a, bool is_state_epoch_a) { debug_assert (status_a.type != nano::election_status_type::ongoing); switch (status_a.type) { @@ -320,7 +320,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co logger.always_log ("Build information: ", BUILD_INFO); logger.always_log ("Database backend: ", store.vendor_get ()); - auto network_label = network_params.network.get_current_network_as_string (); + auto const network_label = network_params.network.get_current_network_as_string (); logger.always_log ("Active network: ", network_label); logger.always_log (boost::str (boost::format ("Work pool running %1% threads %2%") % work.threads.size () % (work.opencl ? "(1 for OpenCL)" : ""))); @@ -340,19 +340,18 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co // First do a pass with a read to see if any writing needs doing, this saves needing to open a write lock (and potentially blocking) auto is_initialized (false); { - auto transaction (store.tx_begin_read ()); - is_initialized = (store.accounts_begin (transaction) != store.accounts_end ()); + auto const transaction (store.tx_begin_read ()); + is_initialized = (store.account.begin (transaction) != store.account.end ()); } - nano::genesis genesis; if (!is_initialized && !flags.read_only) { - auto transaction (store.tx_begin_write ({ tables::accounts, tables::blocks, tables::confirmation_height, tables::frontiers })); + auto const transaction (store.tx_begin_write ({ tables::accounts, tables::blocks, tables::confirmation_height, tables::frontiers })); // Store was empty meaning we just created it, add the genesis block - store.initialize (transaction, genesis, ledger.cache); + store.initialize (transaction, ledger.cache); } - if (!ledger.block_or_pruned_exists (genesis.hash ())) + if (!ledger.block_or_pruned_exists (config.network_params.ledger.genesis->hash ())) { std::stringstream ss; ss << "Genesis block not found. This commonly indicates a configuration issue, check that the --network or --data_path command line arguments are correct, " @@ -361,7 +360,7 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co { ss << " Beta network may have reset, try clearing database files"; } - auto str = ss.str (); + auto const str = ss.str (); logger.always_log (str); std::cerr << str << std::endl; @@ -389,9 +388,9 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co if ((network_params.network.is_live_network () || network_params.network.is_beta_network ()) && !flags.inactive_node) { - auto bootstrap_weights = get_bootstrap_weights (); + auto const bootstrap_weights = get_bootstrap_weights (); // Use bootstrap weights if initial bootstrap is not completed - bool use_bootstrap_weight = ledger.cache.block_count < bootstrap_weights.first; + const bool use_bootstrap_weight = ledger.cache.block_count < bootstrap_weights.first; if (use_bootstrap_weight) { ledger.bootstrap_weights = bootstrap_weights.second; @@ -405,13 +404,13 @@ nano::node::node (boost::asio::io_context & io_ctx_a, boost::filesystem::path co // Drop unchecked blocks if initial bootstrap is completed if (!flags.disable_unchecked_drop && !use_bootstrap_weight && !flags.read_only) { - auto transaction (store.tx_begin_write ({ tables::unchecked })); - store.unchecked_clear (transaction); + auto const transaction (store.tx_begin_write ({ tables::unchecked })); + store.unchecked.clear (transaction); logger.always_log ("Dropping unchecked blocks"); } } - ledger.pruning = flags.enable_pruning || store.pruned_count (store.tx_begin_read ()) > 0; + ledger.pruning = flags.enable_pruning || store.pruned.count (store.tx_begin_read ()) > 0; if (ledger.pruning) { @@ -460,12 +459,12 @@ void nano::node::do_rpc_callback (boost::asio::ip::tcp::resolver::iterator i_a, req->insert (boost::beast::http::field::content_type, "application/json"); req->body () = *body; req->prepare_payload (); - boost::beast::http::async_write (*sock, *req, [node_l, sock, address, port, req, i_a, target, body, resolver] (boost::system::error_code const & ec, size_t bytes_transferred) mutable { + boost::beast::http::async_write (*sock, *req, [node_l, sock, address, port, req, i_a, target, body, resolver] (boost::system::error_code const & ec, std::size_t bytes_transferred) mutable { if (!ec) { auto sb (std::make_shared ()); auto resp (std::make_shared> ()); - boost::beast::http::async_read (*sock, *sb, *resp, [node_l, sb, resp, sock, address, port, i_a, target, body, resolver] (boost::system::error_code const & ec, size_t bytes_transferred) mutable { + boost::beast::http::async_read (*sock, *sb, *resp, [node_l, sb, resp, sock, address, port, i_a, target, body, resolver] (boost::system::error_code const & ec, std::size_t bytes_transferred) mutable { if (!ec) { if (boost::beast::http::to_status_class (resp->result ()) == boost::beast::http::status_class::successful) @@ -559,7 +558,7 @@ void nano::node::process_active (std::shared_ptr const & incoming) nano::process_return nano::node::process (nano::block & block_a) { - auto transaction (store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending })); + auto const transaction (store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending })); auto result (ledger.process (transaction, block_a)); return result; } @@ -574,7 +573,7 @@ nano::process_return nano::node::process_local (std::shared_ptr con block_processor.wait_write (); // Process block block_post_events post_events ([&store = store] { return store.tx_begin_read (); }); - auto transaction (store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending })); + auto const transaction (store.tx_begin_write ({ tables::accounts, tables::blocks, tables::frontiers, tables::pending })); return block_processor.process_one (transaction, post_events, info, false, nano::block_origin::local); } @@ -644,6 +643,7 @@ void nano::node::start () { port_mapping.start (); } + wallets.start (); if (config.frontiers_confirmation != nano::frontiers_confirmation_mode::disabled) { workers.push_task ([this_l = shared ()] () { @@ -698,26 +698,26 @@ void nano::node::keepalive_preconfigured (std::vector const & peers nano::block_hash nano::node::latest (nano::account const & account_a) { - auto transaction (store.tx_begin_read ()); + auto const transaction (store.tx_begin_read ()); return ledger.latest (transaction, account_a); } nano::uint128_t nano::node::balance (nano::account const & account_a) { - auto transaction (store.tx_begin_read ()); + auto const transaction (store.tx_begin_read ()); return ledger.account_balance (transaction, account_a); } std::shared_ptr nano::node::block (nano::block_hash const & hash_a) { - auto transaction (store.tx_begin_read ()); - return store.block_get (transaction, hash_a); + auto const transaction (store.tx_begin_read ()); + return store.block.get (transaction, hash_a); } std::pair nano::node::balance_pending (nano::account const & account_a, bool only_confirmed_a) { std::pair result; - auto transaction (store.tx_begin_read ()); + auto const transaction (store.tx_begin_read ()); result.first = ledger.account_balance (transaction, account_a, only_confirmed_a); result.second = ledger.account_pending (transaction, account_a, only_confirmed_a); return result; @@ -730,10 +730,10 @@ nano::uint128_t nano::node::weight (nano::account const & account_a) nano::block_hash nano::node::rep_block (nano::account const & account_a) { - auto transaction (store.tx_begin_read ()); + auto const transaction (store.tx_begin_read ()); nano::account_info info; nano::block_hash result (0); - if (!store.account_get (transaction, account_a, info)) + if (!store.account.get (transaction, account_a, info)) { result = ledger.representative (transaction, info.head); } @@ -753,19 +753,19 @@ nano::uint128_t nano::node::minimum_principal_weight (nano::uint128_t const & on void nano::node::long_inactivity_cleanup () { bool perform_cleanup = false; - auto transaction (store.tx_begin_write ({ tables::online_weight, tables::peers })); - if (store.online_weight_count (transaction) > 0) + auto const transaction (store.tx_begin_write ({ tables::online_weight, tables::peers })); + if (store.online_weight.count (transaction) > 0) { - auto sample (store.online_weight_rbegin (transaction)); - auto n (store.online_weight_end ()); + auto sample (store.online_weight.rbegin (transaction)); + auto n (store.online_weight.end ()); debug_assert (sample != n); - auto const one_week_ago = static_cast ((std::chrono::system_clock::now () - std::chrono::hours (7 * 24)).time_since_epoch ().count ()); + auto const one_week_ago = static_cast ((std::chrono::system_clock::now () - std::chrono::hours (7 * 24)).time_since_epoch ().count ()); perform_cleanup = sample->first < one_week_ago; } if (perform_cleanup) { - store.online_weight_clear (transaction); - store.peer_clear (transaction); + store.online_weight.clear (transaction); + store.peer.clear (transaction); logger.always_log ("Removed records of peers and online weight after a long period of inactivity"); } } @@ -785,7 +785,7 @@ void nano::node::ongoing_rep_calculation () void nano::node::ongoing_bootstrap () { - auto next_wakeup (network_params.node.bootstrap_interval); + auto next_wakeup = network_params.network.bootstrap_interval; if (warmed_up < 3) { // Re-attempt bootstrapping more aggressively on startup @@ -816,8 +816,8 @@ void nano::node::ongoing_bootstrap () { // Find last online weight sample (last active time for node) uint64_t last_sample_time (0); - auto last_record = store.online_weight_rbegin (store.tx_begin_read ()); - if (last_record != store.online_weight_end ()) + auto last_record = store.online_weight.rbegin (store.tx_begin_read ()); + if (last_record != store.online_weight.end ()) { last_sample_time = last_record->first; } @@ -845,10 +845,10 @@ void nano::node::ongoing_bootstrap () void nano::node::ongoing_peer_store () { - bool stored (network.tcp_channels.store_all (true)); + const bool stored (network.tcp_channels.store_all (true)); network.udp_channels.store_all (!stored); std::weak_ptr node_w (shared_from_this ()); - workers.add_timed_task (std::chrono::steady_clock::now () + network_params.node.peer_interval, [node_w] () { + workers.add_timed_task (std::chrono::steady_clock::now () + network_params.network.peer_dump_interval, [node_w] () { if (auto node_l = node_w.lock ()) { node_l->ongoing_peer_store (); @@ -891,7 +891,7 @@ void nano::node::bootstrap_wallet () std::deque accounts; { nano::lock_guard lock (wallets.mutex); - auto transaction (wallets.tx_begin_read ()); + auto const transaction (wallets.tx_begin_read ()); for (auto i (wallets.items.begin ()), n (wallets.items.end ()); i != n && accounts.size () < 128; ++i) { auto & wallet (*i->second); @@ -913,15 +913,15 @@ void nano::node::unchecked_cleanup () { std::vector digests; std::deque cleaning_list; - auto attempt (bootstrap_initiator.current_attempt ()); - bool long_attempt (attempt != nullptr && std::chrono::duration_cast (std::chrono::steady_clock::now () - attempt->attempt_start).count () > config.unchecked_cutoff_time.count ()); + auto const attempt (bootstrap_initiator.current_attempt ()); + const bool long_attempt (attempt != nullptr && std::chrono::duration_cast (std::chrono::steady_clock::now () - attempt->attempt_start).count () > config.unchecked_cutoff_time.count ()); // Collect old unchecked keys if (ledger.cache.block_count >= ledger.bootstrap_weight_max_blocks && !long_attempt) { - auto now (nano::seconds_since_epoch ()); - auto transaction (store.tx_begin_read ()); + auto const now (nano::seconds_since_epoch ()); + auto const transaction (store.tx_begin_read ()); // Max 1M records to clean, max 2 minutes reading to prevent slow i/o systems issues - for (auto i (store.unchecked_begin (transaction)), n (store.unchecked_end ()); i != n && cleaning_list.size () < 1024 * 1024 && nano::seconds_since_epoch () - now < 120; ++i) + for (auto i (store.unchecked.begin (transaction)), n (store.unchecked.end ()); i != n && cleaning_list.size () < 1024 * 1024 && nano::seconds_since_epoch () - now < 120; ++i) { nano::unchecked_key const & key (i->first); nano::unchecked_info const & info (i->second); @@ -939,15 +939,15 @@ void nano::node::unchecked_cleanup () // Delete old unchecked keys in batches while (!cleaning_list.empty ()) { - size_t deleted_count (0); - auto transaction (store.tx_begin_write ({ tables::unchecked })); + std::size_t deleted_count (0); + auto const transaction (store.tx_begin_write ({ tables::unchecked })); while (deleted_count++ < 2 * 1024 && !cleaning_list.empty ()) { auto key (cleaning_list.front ()); cleaning_list.pop_front (); - if (store.unchecked_exists (transaction, key)) + if (store.unchecked.exists (transaction, key)) { - store.unchecked_del (transaction, key); + store.unchecked.del (transaction, key); } } } @@ -976,8 +976,8 @@ bool nano::node::collect_ledger_pruning_targets (std::deque & { uint64_t read_operations (0); bool finish_transaction (false); - auto transaction (store.tx_begin_read ()); - for (auto i (store.confirmation_height_begin (transaction, last_account_a)), n (store.confirmation_height_end ()); i != n && !finish_transaction;) + auto const transaction (store.tx_begin_read ()); + for (auto i (store.confirmation_height.begin (transaction, last_account_a)), n (store.confirmation_height.end ()); i != n && !finish_transaction;) { ++read_operations; auto const & account (i->first); @@ -985,7 +985,7 @@ bool nano::node::collect_ledger_pruning_targets (std::deque & uint64_t depth (0); while (!hash.is_zero () && depth < max_depth_a) { - auto block (store.block_get (transaction, hash)); + auto block (store.block.get (transaction, hash)); if (block != nullptr) { if (block->sideband ().timestamp > cutoff_time_a || depth == 0) @@ -1066,7 +1066,7 @@ void nano::node::ledger_pruning (uint64_t const batch_size_a, bool bootstrap_wei } } } - auto log_message (boost::str (boost::format ("Total recently pruned block count: %1%") % pruned_count)); + auto const log_message (boost::str (boost::format ("Total recently pruned block count: %1%") % pruned_count)); if (!log_to_cout_a) { logger.always_log (log_message); @@ -1081,7 +1081,7 @@ void nano::node::ongoing_ledger_pruning () { auto bootstrap_weight_reached (ledger.cache.block_count >= ledger.bootstrap_weight_max_blocks); ledger_pruning (flags.block_processor_batch_size != 0 ? flags.block_processor_batch_size : 2 * 1024, bootstrap_weight_reached, false); - auto ledger_pruning_interval (bootstrap_weight_reached ? config.max_pruning_age : std::min (config.max_pruning_age, std::chrono::seconds (15 * 60))); + auto const ledger_pruning_interval (bootstrap_weight_reached ? config.max_pruning_age : std::min (config.max_pruning_age, std::chrono::seconds (15 * 60))); auto this_l (shared ()); workers.add_timed_task (std::chrono::steady_clock::now () + ledger_pruning_interval, [this_l] () { this_l->workers.push_task ([this_l] () { @@ -1112,7 +1112,7 @@ uint64_t nano::node::default_difficulty (nano::work_version const version_a) con switch (version_a) { case nano::work_version::work_1: - result = nano::work_threshold_base (version_a); + result = network_params.work.threshold_base (version_a); break; default: debug_assert (false && "Invalid version specified to default_difficulty"); @@ -1126,7 +1126,7 @@ uint64_t nano::node::default_receive_difficulty (nano::work_version const versio switch (version_a) { case nano::work_version::work_1: - result = network_params.network.publish_thresholds.epoch_2_receive; + result = network_params.work.epoch_2_receive; break; default: debug_assert (false && "Invalid version specified to default_receive_difficulty"); @@ -1205,23 +1205,19 @@ boost::optional nano::node::work_generate_blocking (nano::root const & void nano::node::add_initial_peers () { + if (flags.disable_add_initial_peers) + { + logger.always_log ("Skipping add_initial_peers because disable_add_initial_peers is set"); + return; + } + auto transaction (store.tx_begin_read ()); - for (auto i (store.peers_begin (transaction)), n (store.peers_end ()); i != n; ++i) + for (auto i (store.peer.begin (transaction)), n (store.peer.end ()); i != n; ++i) { nano::endpoint endpoint (boost::asio::ip::address_v6 (i->first.address_bytes ()), i->first.port ()); if (!network.reachout (endpoint, config.allow_local_peers)) { - std::weak_ptr node_w (shared_from_this ()); - network.tcp_channels.start_tcp (endpoint, [node_w] (std::shared_ptr const & channel_a) { - if (auto node_l = node_w.lock ()) - { - node_l->network.send_keepalive (channel_a); - if (!node_l->flags.disable_rep_crawler) - { - node_l->rep_crawler.query (channel_a); - } - } - }); + network.tcp_channels.start_tcp (endpoint); } } } @@ -1283,7 +1279,7 @@ void nano::node::receive_confirmed (nano::transaction const & block_transaction_ nano::account representative; nano::pending_info pending; representative = wallet->store.representative (wallet_transaction); - auto error (store.pending_get (block_transaction_a, nano::pending_key (destination_a, hash_a), pending)); + auto error (store.pending.get (block_transaction_a, nano::pending_key (destination_a, hash_a), pending)); if (!error) { auto amount (pending.amount.number ()); @@ -1305,7 +1301,7 @@ void nano::node::receive_confirmed (nano::transaction const & block_transaction_ } } -void nano::node::process_confirmed_data (nano::transaction const & transaction_a, std::shared_ptr const & block_a, nano::block_hash const & hash_a, nano::account & account_a, nano::uint128_t & amount_a, bool & is_state_send_a, nano::account & pending_account_a) +void nano::node::process_confirmed_data (nano::transaction const & transaction_a, std::shared_ptr const & block_a, nano::block_hash const & hash_a, nano::account & account_a, nano::uint128_t & amount_a, bool & is_state_send_a, bool & is_state_epoch_a, nano::account & pending_account_a) { // Faster account calculation account_a = block_a->account (); @@ -1317,8 +1313,8 @@ void nano::node::process_confirmed_data (nano::transaction const & transaction_a auto previous (block_a->previous ()); bool error (false); auto previous_balance (ledger.balance_safe (transaction_a, previous, error)); - auto block_balance (store.block_balance_calculated (block_a)); - if (hash_a != ledger.network_params.ledger.genesis_account) + auto block_balance (store.block.balance_calculated (block_a)); + if (hash_a != ledger.constants.genesis->account ()) { if (!error) { @@ -1331,7 +1327,7 @@ void nano::node::process_confirmed_data (nano::transaction const & transaction_a } else { - amount_a = ledger.network_params.ledger.genesis_amount; + amount_a = nano::dev::constants.genesis_amount; } if (auto state = dynamic_cast (block_a.get ())) { @@ -1339,6 +1335,10 @@ void nano::node::process_confirmed_data (nano::transaction const & transaction_a { is_state_send_a = true; } + if (amount_a == 0 && network_params.ledger.epochs.is_epoch_link (state->link ())) + { + is_state_epoch_a = true; + } pending_account_a = state->hashables.link.as_account (); } if (auto send = dynamic_cast (block_a.get ())) @@ -1350,8 +1350,8 @@ void nano::node::process_confirmed_data (nano::transaction const & transaction_a void nano::node::process_confirmed (nano::election_status const & status_a, uint64_t iteration_a) { auto hash (status_a.winner->hash ()); - const auto num_iters = (config.block_processor_batch_max_time / network_params.node.process_confirmed_interval) * 4; - if (auto block_l = ledger.store.block_get (ledger.store.tx_begin_read (), hash)) + auto const num_iters = (config.block_processor_batch_max_time / network_params.node.process_confirmed_interval) * 4; + if (auto block_l = ledger.store.block.get (ledger.store.tx_begin_read (), hash)) { active.add_recently_confirmed (block_l->qualified_root (), hash); confirmation_height_processor.add (block_l); @@ -1396,7 +1396,7 @@ bool nano::block_arrival::recent (nano::block_hash const & hash_a) std::unique_ptr nano::collect_container_info (block_arrival & block_arrival, std::string const & name) { - size_t count = 0; + std::size_t count = 0; { nano::lock_guard guard (block_arrival.mutex); count = block_arrival.arrival.size (); @@ -1416,7 +1416,7 @@ std::shared_ptr nano::node::shared () int nano::node::store_version () { auto transaction (store.tx_begin_read ()); - return store.version_get (transaction); + return store.version.get (transaction); } bool nano::node::init_error () const @@ -1439,7 +1439,7 @@ bool nano::node::epoch_upgrader (nano::raw_key const & prv_a, nano::epoch epoch_ return error; } -void nano::node::set_bandwidth_params (size_t limit, double ratio) +void nano::node::set_bandwidth_params (std::size_t limit, double ratio) { config.bandwidth_limit_burst_ratio = ratio; config.bandwidth_limit = limit; @@ -1453,7 +1453,7 @@ void nano::node::epoch_upgrader_impl (nano::raw_key const & prv_a, nano::epoch e auto upgrader_process = [] (nano::node & node_a, std::atomic & counter, std::shared_ptr const & epoch, uint64_t difficulty, nano::public_key const & signer_a, nano::root const & root_a, nano::account const & account_a) { epoch->block_work_set (node_a.work_generate_blocking (nano::work_version::work_1, root_a, difficulty).value_or (0)); bool valid_signature (!nano::validate_message (signer_a, epoch->hash (), epoch->block_signature ())); - bool valid_work (epoch->difficulty () >= difficulty); + bool valid_work (node_a.network_params.work.difficulty (*epoch) >= difficulty); nano::process_result result (nano::process_result::old); if (valid_signature && valid_work) { @@ -1484,7 +1484,7 @@ void nano::node::epoch_upgrader_impl (nano::raw_key const & prv_a, nano::epoch e class account_upgrade_item final { public: - nano::account account{ 0 }; + nano::account account{}; uint64_t modified{ 0 }; }; class account_tag @@ -1515,7 +1515,7 @@ void nano::node::epoch_upgrader_impl (nano::raw_key const & prv_a, nano::epoch e { auto transaction (store.tx_begin_read ()); // Collect accounts to upgrade - for (auto i (store.accounts_begin (transaction)), n (store.accounts_end ()); i != n && accounts_list.size () < count_limit; ++i) + for (auto i (store.account.begin (transaction)), n (store.account.end ()); i != n && accounts_list.size () < count_limit; ++i) { nano::account const & account (i->first); nano::account_info const & info (i->second); @@ -1537,10 +1537,10 @@ void nano::node::epoch_upgrader_impl (nano::raw_key const & prv_a, nano::epoch e auto transaction (store.tx_begin_read ()); nano::account_info info; nano::account const & account (i->account); - if (!store.account_get (transaction, account, info) && info.epoch () < epoch_a) + if (!store.account.get (transaction, account, info) && info.epoch () < epoch_a) { ++attempts; - auto difficulty (nano::work_threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true))); + auto difficulty (network_params.work.threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true))); nano::root const & root (info.head); std::shared_ptr epoch = builder.state () .account (account) @@ -1607,18 +1607,18 @@ void nano::node::epoch_upgrader_impl (nano::raw_key const & prv_a, nano::epoch e uint64_t workers (0); uint64_t attempts (0); auto transaction (store.tx_begin_read ()); - for (auto i (store.pending_begin (transaction, nano::pending_key (1, 0))), n (store.pending_end ()); i != n && attempts < upgrade_batch_size && attempts < count_limit && !stopped;) + for (auto i (store.pending.begin (transaction, nano::pending_key (1, 0))), n (store.pending.end ()); i != n && attempts < upgrade_batch_size && attempts < count_limit && !stopped;) { bool to_next_account (false); nano::pending_key const & key (i->first); - if (!store.account_exists (transaction, key.account)) + if (!store.account.exists (transaction, key.account)) { nano::pending_info const & info (i->second); if (info.epoch < epoch_a) { ++attempts; release_assert (nano::epochs::is_sequential (info.epoch, epoch_a)); - auto difficulty (nano::work_threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true))); + auto difficulty (network_params.work.threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true))); nano::root const & root (key.account); nano::account const & account (key.account); std::shared_ptr epoch = builder.state () @@ -1668,7 +1668,7 @@ void nano::node::epoch_upgrader_impl (nano::raw_key const & prv_a, nano::epoch e } else { - i = store.pending_begin (transaction, nano::pending_key (key.account.number () + 1, 0)); + i = store.pending.begin (transaction, nano::pending_key (key.account.number () + 1, 0)); } } else @@ -1709,9 +1709,9 @@ void nano::node::epoch_upgrader_impl (nano::raw_key const & prv_a, nano::epoch e std::pair nano::node::get_bootstrap_weights () const { std::unordered_map weights; - const uint8_t * weight_buffer = network_params.network.is_live_network () ? nano_bootstrap_weights_live : nano_bootstrap_weights_beta; - size_t weight_size = network_params.network.is_live_network () ? nano_bootstrap_weights_live_size : nano_bootstrap_weights_beta_size; - nano::bufferstream weight_stream ((const uint8_t *)weight_buffer, weight_size); + uint8_t const * weight_buffer = network_params.network.is_live_network () ? nano_bootstrap_weights_live : nano_bootstrap_weights_beta; + std::size_t weight_size = network_params.network.is_live_network () ? nano_bootstrap_weights_live_size : nano_bootstrap_weights_beta_size; + nano::bufferstream weight_stream ((uint8_t const *)weight_buffer, weight_size); nano::uint128_union block_height; uint64_t max_blocks = 0; if (!nano::try_read (weight_stream, block_height)) @@ -1745,19 +1745,20 @@ void nano::node::populate_backlog () { auto transaction = store.tx_begin_read (); auto count = 0; - for (auto i = store.accounts_begin (transaction, next), n = store.accounts_end (); !stopped && i != n && count < chunk_size; ++i, ++count, ++total) + for (auto i = store.account.begin (transaction, next), n = store.account.end (); !stopped && i != n && count < chunk_size; ++i, ++count, ++total) { auto const & account = i->first; scheduler.activate (account, transaction); next = account.number () + 1; } - done = store.accounts_begin (transaction, next) == store.accounts_end (); + done = store.account.begin (transaction, next) == store.account.end (); } } nano::node_wrapper::node_wrapper (boost::filesystem::path const & path_a, boost::filesystem::path const & config_path_a, nano::node_flags const & node_flags_a) : + network_params{ nano::network_constants::active_network }, io_context (std::make_shared ()), - work (1) + work{ network_params.network, 1 } { boost::system::error_code error_chmod; @@ -1766,7 +1767,7 @@ nano::node_wrapper::node_wrapper (boost::filesystem::path const & path_a, boost: */ boost::filesystem::create_directories (path_a); nano::set_secure_perm_directory (path_a, error_chmod); - nano::daemon_config daemon_config (path_a); + nano::daemon_config daemon_config{ path_a, network_params }; auto error = nano::read_node_config_toml (config_path_a, daemon_config, node_flags_a.config_overrides); if (error) { @@ -1781,7 +1782,7 @@ nano::node_wrapper::node_wrapper (boost::filesystem::path const & path_a, boost: } auto & node_config = daemon_config.node; - node_config.peering_port = nano::get_available_port (); + node_config.peering_port = 24000; node_config.logging.max_size = std::numeric_limits::max (); node_config.logging.init (path_a); @@ -1819,12 +1820,12 @@ nano::node_flags const & nano::inactive_node_flag_defaults () return node_flags; } -std::unique_ptr nano::make_store (nano::logger_mt & logger, boost::filesystem::path const & path, bool read_only, bool add_db_postfix, nano::rocksdb_config const & rocksdb_config, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, nano::lmdb_config const & lmdb_config_a, bool backup_before_upgrade) +std::unique_ptr nano::make_store (nano::logger_mt & logger, boost::filesystem::path const & path, nano::ledger_constants & constants, bool read_only, bool add_db_postfix, nano::rocksdb_config const & rocksdb_config, nano::txn_tracking_config const & txn_tracking_config_a, std::chrono::milliseconds block_processor_batch_max_time_a, nano::lmdb_config const & lmdb_config_a, bool backup_before_upgrade) { - if (rocksdb_config.enable || using_rocksdb_in_tests ()) + if (rocksdb_config.enable) { - return std::make_unique (logger, add_db_postfix ? path / "rocksdb" : path, rocksdb_config, read_only); + return std::make_unique (logger, add_db_postfix ? path / "rocksdb" : path, constants, rocksdb_config, read_only); } - return std::make_unique (logger, add_db_postfix ? path / "data.ldb" : path, txn_tracking_config_a, block_processor_batch_max_time_a, lmdb_config_a, backup_before_upgrade); + return std::make_unique (logger, add_db_postfix ? path / "data.ldb" : path, constants, txn_tracking_config_a, block_processor_batch_max_time_a, lmdb_config_a, backup_before_upgrade); } diff --git a/nano/node/node.hpp b/nano/node/node.hpp index 5261f8988d..a188940d43 100644 --- a/nano/node/node.hpp +++ b/nano/node/node.hpp @@ -74,7 +74,7 @@ class block_arrival final arrival; // clang-format on nano::mutex mutex{ mutex_identifier (mutexes::block_arrival) }; - static size_t constexpr arrival_size_min = 8 * 1024; + static std::size_t constexpr arrival_size_min = 8 * 1024; static std::chrono::seconds constexpr arrival_time_min = std::chrono::seconds (300); }; @@ -100,10 +100,10 @@ class node final : public std::enable_shared_from_this std::shared_ptr shared (); int store_version (); void receive_confirmed (nano::transaction const & block_transaction_a, nano::block_hash const & hash_a, nano::account const & destination_a); - void process_confirmed_data (nano::transaction const &, std::shared_ptr const &, nano::block_hash const &, nano::account &, nano::uint128_t &, bool &, nano::account &); + void process_confirmed_data (nano::transaction const &, std::shared_ptr const &, nano::block_hash const &, nano::account &, nano::uint128_t &, bool &, bool &, nano::account &); void process_confirmed (nano::election_status const &, uint64_t = 0); void process_active (std::shared_ptr const &); - nano::process_return process (nano::block &); + [[nodiscard]] nano::process_return process (nano::block &); nano::process_return process_local (std::shared_ptr const &); void process_local_async (std::shared_ptr const &); void keepalive_preconfigured (std::vector const &); @@ -148,14 +148,14 @@ class node final : public std::enable_shared_from_this bool online () const; bool init_error () const; bool epoch_upgrader (nano::raw_key const &, nano::epoch, uint64_t, uint64_t); - void set_bandwidth_params (size_t limit, double ratio); + void set_bandwidth_params (std::size_t limit, double ratio); std::pair get_bootstrap_weights () const; void populate_backlog (); nano::write_database_queue write_database_queue; boost::asio::io_context & io_ctx; boost::latch node_initialized_latch; - nano::network_params network_params; nano::node_config config; + nano::network_params & network_params; nano::stat stats; nano::thread_pool workers; std::shared_ptr websocket_server; @@ -163,8 +163,8 @@ class node final : public std::enable_shared_from_this nano::work_pool & work; nano::distributed_work_factory distributed_work; nano::logger_mt logger; - std::unique_ptr store_impl; - nano::block_store & store; + std::unique_ptr store_impl; + nano::store & store; std::unique_ptr wallets_store_impl; nano::wallets_store & wallets_store; nano::gap_cache gap_cache; @@ -192,7 +192,7 @@ class node final : public std::enable_shared_from_this nano::election_scheduler scheduler; nano::request_aggregator aggregator; nano::wallets wallets; - const std::chrono::steady_clock::time_point startup_time; + std::chrono::steady_clock::time_point const startup_time; std::chrono::seconds unchecked_cutoff = std::chrono::seconds (7 * 24 * 60 * 60); // Week std::atomic unresponsive_work_peers{ false }; std::atomic stopped{ false }; @@ -223,6 +223,7 @@ class node_wrapper final node_wrapper (boost::filesystem::path const & path_a, boost::filesystem::path const & config_path_a, nano::node_flags const & node_flags_a); ~node_wrapper (); + nano::network_params network_params; std::shared_ptr io_context; nano::work_pool work; std::shared_ptr node; diff --git a/nano/node/node_observers.hpp b/nano/node/node_observers.hpp index 78c0f0e032..cea357eb10 100644 --- a/nano/node/node_observers.hpp +++ b/nano/node/node_observers.hpp @@ -11,7 +11,7 @@ class telemetry; class node_observers final { public: - using blocks_t = nano::observer_set const &, nano::account const &, nano::uint128_t const &, bool>; + using blocks_t = nano::observer_set const &, nano::account const &, nano::uint128_t const &, bool, bool>; blocks_t blocks; nano::observer_set wallet; nano::observer_set, std::shared_ptr, nano::vote_code> vote; diff --git a/nano/node/node_rpc_config.cpp b/nano/node/node_rpc_config.cpp index c83f8c0904..4847d0cdce 100644 --- a/nano/node/node_rpc_config.cpp +++ b/nano/node/node_rpc_config.cpp @@ -59,6 +59,5 @@ nano::error nano::node_rpc_config::deserialize_json (bool & upgraded_a, nano::js void nano::node_rpc_config::set_request_callback (std::function callback_a) { - debug_assert (nano::network_constants ().is_dev_network ()); request_callback = std::move (callback_a); } diff --git a/nano/node/nodeconfig.cpp b/nano/node/nodeconfig.cpp index cb5048cc38..93974bcbb5 100644 --- a/nano/node/nodeconfig.cpp +++ b/nano/node/nodeconfig.cpp @@ -12,23 +12,26 @@ namespace { -const char * preconfigured_peers_key = "preconfigured_peers"; -const char * signature_checker_threads_key = "signature_checker_threads"; -const char * pow_sleep_interval_key = "pow_sleep_interval"; -const char * default_beta_peer_network = "peering-beta.nano.org"; -const char * default_live_peer_network = "livenet.banano.cc"; -const std::string default_test_peer_network = nano::get_env_or_default ("NANO_TEST_PEER_NETWORK", "peering-test.nano.org"); +char const * preconfigured_peers_key = "preconfigured_peers"; +char const * signature_checker_threads_key = "signature_checker_threads"; +char const * pow_sleep_interval_key = "pow_sleep_interval"; +char const * default_beta_peer_network = "peering-beta.nano.org"; +char const * default_live_peer_network = "livenet.banano.cc"; +std::string const default_test_peer_network = nano::get_env_or_default ("NANO_TEST_PEER_NETWORK", "peering-test.nano.org"); } -nano::node_config::node_config () : - node_config (0, nano::logging ()) +nano::node_config::node_config (nano::network_params & network_params) : + node_config (0, nano::logging (), network_params) { } -nano::node_config::node_config (uint16_t peering_port_a, nano::logging const & logging_a) : - peering_port (peering_port_a), - logging (logging_a), - external_address (boost::asio::ip::address_v6{}.to_string ()) +nano::node_config::node_config (uint16_t peering_port_a, nano::logging const & logging_a, nano::network_params & network_params) : + network_params{ network_params }, + peering_port{ peering_port_a }, + logging{ logging_a }, + websocket_config{ network_params.network }, + ipc_config{ network_params.network }, + external_address{ boost::asio::ip::address_v6{}.to_string () } { // The default constructor passes 0 to indicate we should use the default port, // which is determined at node startup based on active network. @@ -38,11 +41,11 @@ nano::node_config::node_config (uint16_t peering_port_a, nano::logging const & l } switch (network_params.network.network ()) { - case nano::nano_networks::nano_dev_network: + case nano::networks::nano_dev_network: enable_voting = true; - preconfigured_representatives.push_back (network_params.ledger.genesis_account); + preconfigured_representatives.push_back (network_params.ledger.genesis->account ()); break; - case nano::nano_networks::nano_beta_network: + case nano::networks::nano_beta_network: { preconfigured_peers.push_back (default_beta_peer_network); nano::account offline_representative; @@ -50,7 +53,7 @@ nano::node_config::node_config (uint16_t peering_port_a, nano::logging const & l preconfigured_representatives.emplace_back (offline_representative); break; } - case nano::nano_networks::nano_live_network: + case nano::networks::nano_live_network: preconfigured_peers.push_back (default_live_peer_network); preconfigured_representatives.emplace_back ("36B3AFC042CCB5099DC163FA2BFE42D6E486991B685EAAB0DF73714D91A59400"); preconfigured_representatives.emplace_back ("29126049B40D1755C0A1C02B71646EEAB9E1707C16E94B47100F3228D59B1EB2"); @@ -61,9 +64,9 @@ nano::node_config::node_config (uint16_t peering_port_a, nano::logging const & l // removed a preconfigured_representative break; - case nano::nano_networks::nano_test_network: + case nano::networks::nano_test_network: preconfigured_peers.push_back (default_test_peer_network); - preconfigured_representatives.push_back (network_params.ledger.genesis_account); + preconfigured_representatives.push_back (network_params.ledger.genesis->account ()); break; default: debug_assert (false); @@ -88,7 +91,6 @@ nano::error nano::node_config::serialize_toml (nano::tomlconfig & toml) const toml.put ("bootstrap_connections_max", bootstrap_connections_max, "Maximum number of inbound bootstrap connections. Defaults to 64.\nWarning: a larger amount of connections may use additional system memory.\ntype:uint64"); toml.put ("bootstrap_initiator_threads", bootstrap_initiator_threads, "Number of threads dedicated to concurrent bootstrap attempts. Defaults to 1.\nWarning: a larger amount of attempts may use additional system memory and disk IO.\ntype:uint64"); toml.put ("bootstrap_frontier_request_count", bootstrap_frontier_request_count, "Number frontiers per bootstrap frontier request. Defaults to 1048576.\ntype:uint32,[1024..4294967295]"); - toml.put ("lmdb_max_dbs", deprecated_lmdb_max_dbs, "DEPRECATED: use node.lmdb.max_databases instead.\nMaximum open lmdb databases. Increase default if more than 100 wallets is required.\nNote: external management is recommended when a large number of wallets is required (see https://docs.nano.org/integration-guides/key-management/).\ntype:uint64"); toml.put ("block_processor_batch_max_time", block_processor_batch_max_time.count (), "The maximum time the block processor can continuously process blocks for.\ntype:milliseconds"); toml.put ("allow_local_peers", allow_local_peers, "Enable or disable local host peering.\ntype:bool"); toml.put ("vote_minimum", vote_minimum.to_string_dec (), "Local representatives do not vote if the delegated weight is under this threshold. Saves on system resources.\ntype:string,amount,raw"); @@ -111,6 +113,7 @@ nano::error nano::node_config::serialize_toml (nano::tomlconfig & toml) const toml.put ("frontiers_confirmation", serialize_frontiers_confirmation (frontiers_confirmation), "Mode controlling frontier confirmation rate.\ntype:string,{auto,always,disabled}"); toml.put ("max_queued_requests", max_queued_requests, "Limit for number of queued confirmation requests for one channel, after which new requests are dropped until the queue drops below this value.\ntype:uint32"); toml.put ("confirm_req_batches_max", confirm_req_batches_max, "Limit for the number of confirmation requests for one channel per request attempt\ntype:uint32"); + toml.put ("rep_crawler_weight_minimum", rep_crawler_weight_minimum.to_string_dec (), "Rep crawler minimum weight, if this is less than minimum principal weight then this is taken as the minimum weight a rep must have to be tracked. If you want to track all reps set this to 0. If you do not want this to influence anything then set it to max value. This is only useful for debugging or for people who really know what they are doing.\ntype:string,amount,raw"); auto work_peers_l (toml.create_array ("work_peers", "A list of \"address:port\" entries to identify work peers.")); for (auto i (work_peers.begin ()), n (work_peers.end ()); i != n; ++i) @@ -246,7 +249,7 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml) { preconfigured_representatives.clear (); toml.array_entries_required ("preconfigured_representatives", [this, &toml] (std::string entry) { - nano::account representative (0); + nano::account representative{}; if (representative.decode_account (entry)) { toml.get_error ().set ("Invalid representative account: " + entry); @@ -323,27 +326,10 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml) toml.get ("allow_local_peers", allow_local_peers); toml.get (signature_checker_threads_key, signature_checker_threads); - auto lmdb_max_dbs_default = deprecated_lmdb_max_dbs; - toml.get ("lmdb_max_dbs", deprecated_lmdb_max_dbs); - bool is_deprecated_lmdb_dbs_used = lmdb_max_dbs_default != deprecated_lmdb_max_dbs; - - // Note: using the deprecated setting will result in a fail-fast config error in the future - if (!network_params.network.is_dev_network () && is_deprecated_lmdb_dbs_used) - { - std::cerr << "WARNING: The node.lmdb_max_dbs setting is deprecated and will be removed in a future version." << std::endl; - std::cerr << "Please use the node.lmdb.max_databases setting instead." << std::endl; - } - if (toml.has_key ("lmdb")) { auto lmdb_config_l (toml.get_required_child ("lmdb")); - lmdb_config.deserialize_toml (lmdb_config_l, is_deprecated_lmdb_dbs_used); - - // Note that the lmdb config fails if both the deprecated and new setting are changed. - if (is_deprecated_lmdb_dbs_used) - { - lmdb_config.max_databases = deprecated_lmdb_max_dbs; - } + lmdb_config.deserialize_toml (lmdb_config_l); } boost::asio::ip::address_v6 external_address_l; @@ -356,9 +342,9 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml) toml.get (pow_sleep_interval_key, pow_sleep_interval_l); pow_sleep_interval = std::chrono::nanoseconds (pow_sleep_interval_l); toml.get ("use_memory_pools", use_memory_pools); - toml.get ("confirmation_history_size", confirmation_history_size); - toml.get ("active_elections_size", active_elections_size); - toml.get ("bandwidth_limit", bandwidth_limit); + toml.get ("confirmation_history_size", confirmation_history_size); + toml.get ("active_elections_size", active_elections_size); + toml.get ("bandwidth_limit", bandwidth_limit); toml.get ("bandwidth_limit_burst_ratio", bandwidth_limit_burst_ratio); toml.get ("backup_before_upgrade", backup_before_upgrade); @@ -366,12 +352,21 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml) toml.get ("conf_height_processor_batch_min_time", conf_height_processor_batch_min_time_l); conf_height_processor_batch_min_time = std::chrono::milliseconds (conf_height_processor_batch_min_time_l); - nano::network_constants network; toml.get ("max_work_generate_multiplier", max_work_generate_multiplier); toml.get ("max_queued_requests", max_queued_requests); toml.get ("confirm_req_batches_max", confirm_req_batches_max); + auto rep_crawler_weight_minimum_l (rep_crawler_weight_minimum.to_string_dec ()); + if (toml.has_key ("rep_crawler_weight_minimum")) + { + rep_crawler_weight_minimum_l = toml.get ("rep_crawler_weight_minimum"); + } + if (rep_crawler_weight_minimum.decode_dec (rep_crawler_weight_minimum_l)) + { + toml.get_error ().set ("rep_crawler_weight_minimum contains an invalid decimal amount"); + } + if (toml.has_key ("frontiers_confirmation")) { auto frontiers_confirmation_l (toml.get ("frontiers_confirmation")); @@ -395,7 +390,6 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml) } // Validate ranges - nano::network_params network_params; if (election_hint_weight_percent < 5 || election_hint_weight_percent > 50) { toml.get_error ().set ("election_hint_weight_percent must be a number between 5 and 50"); @@ -408,11 +402,11 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml) { toml.get_error ().set ("io_threads must be non-zero"); } - if (active_elections_size <= 250 && !network.is_dev_network ()) + if (active_elections_size <= 250 && !network_params.network.is_dev_network ()) { toml.get_error ().set ("active_elections_size must be greater than 250"); } - if (bandwidth_limit > std::numeric_limits::max ()) + if (bandwidth_limit > std::numeric_limits::max ()) { toml.get_error ().set ("bandwidth_limit unbounded = 0, default = 10485760, max = 18446744073709551615"); } @@ -432,7 +426,7 @@ nano::error nano::node_config::deserialize_toml (nano::tomlconfig & toml) { toml.get_error ().set ((boost::format ("block_processor_batch_max_time value must be equal or larger than %1%ms") % network_params.node.process_confirmed_interval.count ()).str ()); } - if (max_pruning_age < std::chrono::seconds (5 * 60) && !network.is_dev_network ()) + if (max_pruning_age < std::chrono::seconds (5 * 60) && !network_params.network.is_dev_network ()) { toml.get_error ().set ("max_pruning_age must be greater than or equal to 5 minutes"); } @@ -496,7 +490,6 @@ nano::error nano::node_config::serialize_json (nano::jsonconfig & json) const json.put ("callback_address", callback_address); json.put ("callback_port", callback_port); json.put ("callback_target", callback_target); - json.put ("lmdb_max_dbs", deprecated_lmdb_max_dbs); json.put ("block_processor_batch_max_time", block_processor_batch_max_time.count ()); json.put ("allow_local_peers", allow_local_peers); json.put ("vote_minimum", vote_minimum.to_string_dec ()); @@ -509,6 +502,7 @@ nano::error nano::node_config::serialize_json (nano::jsonconfig & json) const json.put ("external_port", external_port); json.put ("tcp_incoming_connections_max", tcp_incoming_connections_max); json.put ("use_memory_pools", use_memory_pools); + json.put ("rep_crawler_weight_minimum", online_weight_minimum.to_string_dec ()); nano::jsonconfig websocket_l; websocket_config.serialize_json (websocket_l); json.put_child ("websocket", websocket_l); @@ -601,7 +595,7 @@ nano::error nano::node_config::deserialize_json (bool & upgraded_a, nano::jsonco auto preconfigured_representatives_l (json.get_required_child ("preconfigured_representatives")); preconfigured_representatives.clear (); preconfigured_representatives_l.array_entries ([this, &json] (std::string entry) { - nano::account representative (0); + nano::account representative{}; if (representative.decode_account (entry)) { json.get_error ().set ("Invalid representative account: " + entry); @@ -631,6 +625,12 @@ nano::error nano::node_config::deserialize_json (bool & upgraded_a, nano::jsonco json.get_error ().set ("online_weight_minimum contains an invalid decimal amount"); } + auto rep_crawler_weight_minimum_l (json.get ("rep_crawler_weight_minimum")); + if (rep_crawler_weight_minimum.decode_dec (rep_crawler_weight_minimum_l)) + { + json.get_error ().set ("rep_crawler_weight_minimum contains an invalid decimal amount"); + } + auto vote_minimum_l (json.get ("vote_minimum")); if (vote_minimum.decode_dec (vote_minimum_l)) { @@ -679,7 +679,6 @@ nano::error nano::node_config::deserialize_json (bool & upgraded_a, nano::jsonco json.get ("callback_address", callback_address); json.get ("callback_port", callback_port); json.get ("callback_target", callback_target); - json.get ("lmdb_max_dbs", deprecated_lmdb_max_dbs); json.get ("enable_voting", enable_voting); json.get ("allow_local_peers", allow_local_peers); json.get (signature_checker_threads_key, signature_checker_threads); @@ -693,16 +692,15 @@ nano::error nano::node_config::deserialize_json (bool & upgraded_a, nano::jsonco json.get (pow_sleep_interval_key, pow_sleep_interval_l); pow_sleep_interval = std::chrono::nanoseconds (pow_sleep_interval_l); json.get ("use_memory_pools", use_memory_pools); - json.get ("confirmation_history_size", confirmation_history_size); - json.get ("active_elections_size", active_elections_size); - json.get ("bandwidth_limit", bandwidth_limit); + json.get ("confirmation_history_size", confirmation_history_size); + json.get ("active_elections_size", active_elections_size); + json.get ("bandwidth_limit", bandwidth_limit); json.get ("backup_before_upgrade", backup_before_upgrade); auto conf_height_processor_batch_min_time_l (conf_height_processor_batch_min_time.count ()); json.get ("conf_height_processor_batch_min_time", conf_height_processor_batch_min_time_l); conf_height_processor_batch_min_time = std::chrono::milliseconds (conf_height_processor_batch_min_time_l); - nano::network_constants network; // Validate ranges if (password_fanout < 16 || password_fanout > 1024 * 1024) { @@ -712,11 +710,11 @@ nano::error nano::node_config::deserialize_json (bool & upgraded_a, nano::jsonco { json.get_error ().set ("io_threads must be non-zero"); } - if (active_elections_size <= 250 && !network.is_dev_network ()) + if (active_elections_size <= 250 && !network_params.network.is_dev_network ()) { json.get_error ().set ("active_elections_size must be greater than 250"); } - if (bandwidth_limit > std::numeric_limits::max ()) + if (bandwidth_limit > std::numeric_limits::max ()) { json.get_error ().set ("bandwidth_limit unbounded = 0, default = 10485760, max = 18446744073709551615"); } @@ -787,7 +785,7 @@ void nano::node_config::deserialize_address (std::string const & entry_a, std::v nano::account nano::node_config::random_representative () const { debug_assert (!preconfigured_representatives.empty ()); - size_t index (nano::random_pool::generate_word32 (0, static_cast (preconfigured_representatives.size () - 1))); + std::size_t index (nano::random_pool::generate_word32 (0, static_cast (preconfigured_representatives.size () - 1))); auto result (preconfigured_representatives[index]); return result; } diff --git a/nano/node/nodeconfig.hpp b/nano/node/nodeconfig.hpp index cf81d51415..9a711759f2 100644 --- a/nano/node/nodeconfig.hpp +++ b/nano/node/nodeconfig.hpp @@ -34,15 +34,15 @@ enum class frontiers_confirmation_mode : uint8_t class node_config { public: - node_config (); - node_config (uint16_t, nano::logging const &); + node_config (nano::network_params & network_params = nano::dev::network_params); + node_config (uint16_t, nano::logging const &, nano::network_params & network_params = nano::dev::network_params); nano::error serialize_json (nano::jsonconfig &) const; nano::error deserialize_json (bool &, nano::jsonconfig &); nano::error serialize_toml (nano::tomlconfig &) const; nano::error deserialize_toml (nano::tomlconfig &); bool upgrade_json (unsigned, nano::jsonconfig &); nano::account random_representative () const; - nano::network_params network_params; + nano::network_params & network_params; uint16_t peering_port{ 0 }; nano::logging logging; std::vector> work_peers; @@ -50,8 +50,9 @@ class node_config std::vector preconfigured_peers; std::vector preconfigured_representatives; unsigned bootstrap_fraction_numerator{ 1 }; - nano::amount receive_minimum{ nano::banoshi_ratio }; + nano::amount receive_minimum{ nano::RAW_ratio }; nano::amount vote_minimum{ nano::MBAN_ratio }; + nano::amount rep_crawler_weight_minimum{ "FFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFF" }; std::chrono::milliseconds vote_generator_delay{ std::chrono::milliseconds (100) }; unsigned vote_generator_threshold{ 3 }; nano::amount online_weight_minimum{ 900 * nano::MBAN_ratio }; @@ -69,11 +70,10 @@ class node_config uint32_t bootstrap_frontier_request_count{ 1024 * 1024 }; nano::websocket::config websocket_config; nano::diagnostics_config diagnostics_config; - size_t confirmation_history_size{ 2048 }; + std::size_t confirmation_history_size{ 2048 }; std::string callback_address; uint16_t callback_port{ 0 }; std::string callback_target; - [[deprecated]] int deprecated_lmdb_max_dbs{ 128 }; bool allow_local_peers{ !(network_params.network.is_live_network () || network_params.network.is_test_network ()) }; // disable by default for live network nano::stat_config stat_config; nano::ipc::ipc_config ipc_config; @@ -84,7 +84,7 @@ class node_config /** Timeout for initiated async operations */ std::chrono::seconds tcp_io_timeout{ (network_params.network.is_dev_network () && !is_sanitizer_build) ? std::chrono::seconds (5) : std::chrono::seconds (15) }; std::chrono::nanoseconds pow_sleep_interval{ 0 }; - size_t active_elections_size{ 5000 }; + std::size_t active_elections_size{ 5000 }; /** Default maximum incoming TCP connections, including realtime network & bootstrap */ unsigned tcp_incoming_connections_max{ 2048 }; bool use_memory_pools{ true }; @@ -92,7 +92,7 @@ class node_config static std::chrono::seconds constexpr keepalive_cutoff = keepalive_period * 5; static std::chrono::minutes constexpr wallet_backup_interval = std::chrono::minutes (5); /** Default outbound traffic shaping is 10MB/s */ - size_t bandwidth_limit{ 2 * 1024 * 1024 }; + std::size_t bandwidth_limit{ 2 * 1024 * 1024 }; /** By default, allow bursts of 15MB/s (not sustainable) */ double bandwidth_limit_burst_ratio{ 3. }; std::chrono::milliseconds conf_height_processor_batch_min_time{ 50 }; @@ -122,6 +122,7 @@ class node_flags final public: std::vector config_overrides; std::vector rpc_config_overrides; + bool disable_add_initial_peers{ false }; // For testing only bool disable_backup{ false }; bool disable_lazy_bootstrap{ false }; bool disable_legacy_bootstrap{ false }; @@ -143,19 +144,21 @@ class node_flags final bool disable_block_processor_republishing{ false }; bool allow_bootstrap_peers_duplicates{ false }; bool disable_max_peers_per_ip{ false }; // For testing only + bool disable_max_peers_per_subnetwork{ false }; // For testing only bool force_use_write_database_queue{ false }; // For testing only. RocksDB does not use the database queue, but some tests rely on it being used. bool disable_search_pending{ false }; // For testing only bool enable_pruning{ false }; bool fast_bootstrap{ false }; bool read_only{ false }; + bool disable_connection_cleanup{ false }; nano::confirmation_height_mode confirmation_height_processor_mode{ nano::confirmation_height_mode::automatic }; nano::generate_cache generate_cache; bool inactive_node{ false }; - size_t block_processor_batch_size{ 0 }; - size_t block_processor_full_size{ 65536 }; - size_t block_processor_verification_size{ 0 }; - size_t inactive_votes_cache_size{ 16 * 1024 }; - size_t vote_processor_capacity{ 144 * 1024 }; - size_t bootstrap_interval{ 0 }; // For testing only + std::size_t block_processor_batch_size{ 0 }; + std::size_t block_processor_full_size{ 65536 }; + std::size_t block_processor_verification_size{ 0 }; + std::size_t inactive_votes_cache_size{ 16 * 1024 }; + std::size_t vote_processor_capacity{ 144 * 1024 }; + std::size_t bootstrap_interval{ 0 }; // For testing only }; } diff --git a/nano/node/online_reps.cpp b/nano/node/online_reps.cpp index 774b81dfb4..4dbbcd8a2e 100644 --- a/nano/node/online_reps.cpp +++ b/nano/node/online_reps.cpp @@ -1,7 +1,7 @@ #include #include -#include #include +#include nano::online_reps::online_reps (nano::ledger & ledger_a, nano::node_config const & config_a) : ledger{ ledger_a }, @@ -41,13 +41,13 @@ void nano::online_reps::sample () { auto transaction (ledger.store.tx_begin_write ({ tables::online_weight })); // Discard oldest entries - while (ledger.store.online_weight_count (transaction) >= config.network_params.node.max_weight_samples) + while (ledger.store.online_weight.count (transaction) >= config.network_params.node.max_weight_samples) { - auto oldest (ledger.store.online_weight_begin (transaction)); - debug_assert (oldest != ledger.store.online_weight_end ()); - ledger.store.online_weight_del (transaction, oldest->first); + auto oldest (ledger.store.online_weight.begin (transaction)); + debug_assert (oldest != ledger.store.online_weight.end ()); + ledger.store.online_weight.del (transaction, oldest->first); } - ledger.store.online_weight_put (transaction, std::chrono::system_clock::now ().time_since_epoch ().count (), online_l); + ledger.store.online_weight.put (transaction, std::chrono::system_clock::now ().time_since_epoch ().count (), online_l); trend_l = calculate_trend (transaction); } lock.lock (); @@ -69,7 +69,7 @@ nano::uint128_t nano::online_reps::calculate_trend (nano::transaction & transact std::vector items; items.reserve (config.network_params.node.max_weight_samples + 1); items.push_back (config.online_weight_minimum.number ()); - for (auto i (ledger.store.online_weight_begin (transaction_a)), n (ledger.store.online_weight_end ()); i != n; ++i) + for (auto i (ledger.store.online_weight.begin (transaction_a)), n (ledger.store.online_weight.end ()); i != n; ++i) { items.push_back (i->second.number ()); } @@ -118,7 +118,7 @@ void nano::online_reps::clear () std::unique_ptr nano::collect_container_info (online_reps & online_reps, std::string const & name) { - size_t count; + std::size_t count; { nano::lock_guard guard (online_reps.mutex); count = online_reps.reps.size (); diff --git a/nano/node/online_reps.hpp b/nano/node/online_reps.hpp index 9e327ef3de..92eced3c95 100644 --- a/nano/node/online_reps.hpp +++ b/nano/node/online_reps.hpp @@ -68,7 +68,7 @@ class online_reps final nano::uint128_t online_m; nano::uint128_t minimum; - friend class election_quorum_minimum_update_weight_before_quorum_checks_Test; + friend class election_DISABLED_quorum_minimum_update_weight_before_quorum_checks_Test; friend std::unique_ptr collect_container_info (online_reps & online_reps, std::string const & name); }; diff --git a/nano/node/openclwork.cpp b/nano/node/openclwork.cpp index 755c476a0b..ce5a3342ec 100644 --- a/nano/node/openclwork.cpp +++ b/nano/node/openclwork.cpp @@ -161,7 +161,7 @@ void nano::opencl_environment::dump (std::ostream & stream) if (nano::opencl_loaded) { auto index (0); - size_t device_count (0); + std::size_t device_count (0); for (auto & i : platforms) { device_count += i.devices.size (); @@ -173,7 +173,7 @@ void nano::opencl_environment::dump (std::ostream & stream) stream << "Platform: " << index << std::endl; for (auto j (queries.begin ()), m (queries.end ()); j != m; ++j) { - size_t platformInfoCount = 0; + std::size_t platformInfoCount = 0; clGetPlatformInfo (i->platform, *j, 0, nullptr, &platformInfoCount); std::vector info (platformInfoCount); clGetPlatformInfo (i->platform, *j, info.size (), info.data (), nullptr); @@ -185,13 +185,13 @@ void nano::opencl_environment::dump (std::ostream & stream) stream << "Device: " << j - i->devices.begin () << std::endl; for (auto k (queries.begin ()), o (queries.end ()); k != o; ++k) { - size_t platformInfoCount = 0; + std::size_t platformInfoCount = 0; clGetDeviceInfo (*j, *k, 0, nullptr, &platformInfoCount); std::vector info (platformInfoCount); clGetDeviceInfo (*j, *k, info.size (), info.data (), nullptr); stream << '\t' << info.data () << std::endl; } - size_t deviceTypeCount = 0; + std::size_t deviceTypeCount = 0; clGetDeviceInfo (*j, CL_DEVICE_TYPE, 0, nullptr, &deviceTypeCount); std::vector deviceTypeInfo (deviceTypeCount); clGetDeviceInfo (*j, CL_DEVICE_TYPE, deviceTypeCount, deviceTypeInfo.data (), 0); @@ -218,12 +218,12 @@ void nano::opencl_environment::dump (std::ostream & stream) break; } stream << '\t' << device_type_string << std::endl; - size_t compilerAvailableCount = 0; + std::size_t compilerAvailableCount = 0; clGetDeviceInfo (*j, CL_DEVICE_COMPILER_AVAILABLE, 0, nullptr, &compilerAvailableCount); std::vector compilerAvailableInfo (compilerAvailableCount); clGetDeviceInfo (*j, CL_DEVICE_COMPILER_AVAILABLE, compilerAvailableCount, compilerAvailableInfo.data (), 0); stream << "\tCompiler available: " << (compilerAvailableInfo[0] ? "true" : "false") << std::endl; - size_t computeUnitsAvailableCount = 0; + std::size_t computeUnitsAvailableCount = 0; clGetDeviceInfo (*j, CL_DEVICE_MAX_COMPUTE_UNITS, 0, nullptr, &computeUnitsAvailableCount); std::vector computeUnitsAvailableInfo (computeUnitsAvailableCount); clGetDeviceInfo (*j, CL_DEVICE_MAX_COMPUTE_UNITS, computeUnitsAvailableCount, computeUnitsAvailableInfo.data (), 0); @@ -250,7 +250,7 @@ void nano::opencl_environment::dump (std::ostream & stream) } } -nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & config_a, nano::opencl_environment & environment_a, nano::logger_mt & logger_a) : +nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & config_a, nano::opencl_environment & environment_a, nano::logger_mt & logger_a, nano::work_thresholds & work) : config (config_a), context (0), attempt_buffer (0), @@ -260,7 +260,8 @@ nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & conf program (0), kernel (0), queue (0), - logger (logger_a) + logger (logger_a), + work{ work } { error_a |= config.platform >= environment_a.platforms.size (); if (!error_a) @@ -298,7 +299,7 @@ nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & conf if (!error_a) { cl_int item_error (0); - size_t item_size (sizeof (nano::uint256_union)); + std::size_t item_size (sizeof (nano::uint256_union)); item_buffer = clCreateBuffer (context, CL_MEM_READ_ONLY | CL_MEM_HOST_WRITE_ONLY, item_size, nullptr, &item_error); error_a |= item_error != CL_SUCCESS; if (!error_a) @@ -310,7 +311,7 @@ nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & conf { cl_int program_error (0); char const * program_data (opencl_program.data ()); - size_t program_length (opencl_program.size ()); + std::size_t program_length (opencl_program.size ()); program = clCreateProgramWithSource (context, 1, &program_data, &program_length, &program_error); error_a |= program_error != CL_SUCCESS; if (!error_a) @@ -371,7 +372,7 @@ nano::opencl_work::opencl_work (bool & error_a, nano::opencl_config const & conf logger.always_log (boost::str (boost::format ("Build program error %1%") % clBuildProgramError)); for (auto i (selected_devices.begin ()), n (selected_devices.end ()); i != n; ++i) { - size_t log_size (0); + std::size_t log_size (0); clGetProgramBuildInfo (program, *i, CL_PROGRAM_BUILD_LOG, 0, nullptr, &log_size); std::vector log (log_size); clGetProgramBuildInfo (program, *i, CL_PROGRAM_BUILD_LOG, log.size (), log.data (), nullptr); @@ -454,8 +455,8 @@ boost::optional nano::opencl_work::generate_work (nano::work_version c int ticket_l (ticket_a); uint64_t result (0); unsigned thread_count (config.threads); - size_t work_size[] = { thread_count, 0, 0 }; - while (nano::work_difficulty (version_a, root_a, result) < difficulty_a && !error && ticket_a == ticket_l) + std::size_t work_size[] = { thread_count, 0, 0 }; + while (work.difficulty (version_a, root_a, result) < difficulty_a && !error && ticket_a == ticket_l) { result = rand.next (); cl_int write_error1 = clEnqueueWriteBuffer (queue, attempt_buffer, false, 0, sizeof (uint64_t), &result, 0, nullptr, nullptr); @@ -521,7 +522,7 @@ boost::optional nano::opencl_work::generate_work (nano::work_version c return value; } -std::unique_ptr nano::opencl_work::create (bool create_a, nano::opencl_config const & config_a, nano::logger_mt & logger_a) +std::unique_ptr nano::opencl_work::create (bool create_a, nano::opencl_config const & config_a, nano::logger_mt & logger_a, nano::work_thresholds & work) { std::unique_ptr result; if (create_a) @@ -533,7 +534,7 @@ std::unique_ptr nano::opencl_work::create (bool create_a, nan logger_a.always_log (stream.str ()); if (!error) { - result.reset (new nano::opencl_work (error, config_a, environment, logger_a)); + result.reset (new nano::opencl_work (error, config_a, environment, logger_a, work)); if (error) { result.reset (); diff --git a/nano/node/openclwork.hpp b/nano/node/openclwork.hpp index b7e4b5041c..2f452e092e 100644 --- a/nano/node/openclwork.hpp +++ b/nano/node/openclwork.hpp @@ -40,11 +40,11 @@ class work_pool; class opencl_work { public: - opencl_work (bool &, nano::opencl_config const &, nano::opencl_environment &, nano::logger_mt &); + opencl_work (bool &, nano::opencl_config const &, nano::opencl_environment &, nano::logger_mt &, nano::work_thresholds & work); ~opencl_work (); boost::optional generate_work (nano::work_version const, nano::root const &, uint64_t const); boost::optional generate_work (nano::work_version const, nano::root const &, uint64_t const, std::atomic &); - static std::unique_ptr create (bool, nano::opencl_config const &, nano::logger_mt &); + static std::unique_ptr create (bool, nano::opencl_config const &, nano::logger_mt &, nano::work_thresholds & work); nano::opencl_config const & config; nano::mutex mutex; cl_context context; @@ -57,5 +57,6 @@ class opencl_work cl_command_queue queue; nano::xorshift1024star rand; nano::logger_mt & logger; + nano::work_thresholds & work; }; } diff --git a/nano/node/peer_exclusion.cpp b/nano/node/peer_exclusion.cpp index 1ac29e26a8..aebb5c7336 100644 --- a/nano/node/peer_exclusion.cpp +++ b/nano/node/peer_exclusion.cpp @@ -2,10 +2,10 @@ constexpr std::chrono::hours nano::peer_exclusion::exclude_time_hours; constexpr std::chrono::hours nano::peer_exclusion::exclude_remove_hours; -constexpr size_t nano::peer_exclusion::size_max; +constexpr std::size_t nano::peer_exclusion::size_max; constexpr double nano::peer_exclusion::peers_percentage_limit; -uint64_t nano::peer_exclusion::add (nano::tcp_endpoint const & endpoint_a, size_t const network_peers_count_a) +uint64_t nano::peer_exclusion::add (nano::tcp_endpoint const & endpoint_a, std::size_t const network_peers_count_a) { uint64_t result (0); nano::lock_guard guard (mutex); @@ -72,12 +72,12 @@ void nano::peer_exclusion::remove (nano::tcp_endpoint const & endpoint_a) peers.get ().erase (endpoint_a.address ()); } -size_t nano::peer_exclusion::limited_size (size_t const network_peers_count_a) const +std::size_t nano::peer_exclusion::limited_size (std::size_t const network_peers_count_a) const { - return std::min (size_max, static_cast (network_peers_count_a * peers_percentage_limit)); + return std::min (size_max, static_cast (network_peers_count_a * peers_percentage_limit)); } -size_t nano::peer_exclusion::size () const +std::size_t nano::peer_exclusion::size () const { nano::lock_guard guard (mutex); return peers.size (); @@ -87,7 +87,7 @@ std::unique_ptr nano::collect_container_info (na { auto composite = std::make_unique (name); - size_t excluded_peers_count = excluded_peers.size (); + std::size_t excluded_peers_count = excluded_peers.size (); auto sizeof_excluded_peers_element = sizeof (nano::peer_exclusion::ordered_endpoints::value_type); composite->add_component (std::make_unique (container_info{ "peers", excluded_peers_count, sizeof_excluded_peers_element })); diff --git a/nano/node/peer_exclusion.hpp b/nano/node/peer_exclusion.hpp index cadaab5cb7..c809bb9841 100644 --- a/nano/node/peer_exclusion.hpp +++ b/nano/node/peer_exclusion.hpp @@ -40,19 +40,19 @@ class peer_exclusion final mutable nano::mutex mutex; public: - constexpr static size_t size_max = 5000; + constexpr static std::size_t size_max = 5000; constexpr static double peers_percentage_limit = 0.5; constexpr static uint64_t score_limit = 2; constexpr static std::chrono::hours exclude_time_hours = std::chrono::hours (1); constexpr static std::chrono::hours exclude_remove_hours = std::chrono::hours (24); - uint64_t add (nano::tcp_endpoint const &, size_t const); + uint64_t add (nano::tcp_endpoint const &, std::size_t const); bool check (nano::tcp_endpoint const &); void remove (nano::tcp_endpoint const &); - size_t limited_size (size_t const) const; - size_t size () const; + std::size_t limited_size (std::size_t const) const; + std::size_t size () const; - friend class telemetry_remove_peer_different_genesis_Test; + friend class telemetry_DISABLED_remove_peer_different_genesis_Test; friend class telemetry_remove_peer_different_genesis_udp_Test; friend class telemetry_remove_peer_invalid_signature_Test; friend class peer_exclusion_validate_Test; diff --git a/nano/node/plat/posix/openclapi.cpp b/nano/node/plat/posix/openclapi.cpp index 6429cd7385..08dae9f1ba 100644 --- a/nano/node/plat/posix/openclapi.cpp +++ b/nano/node/plat/posix/openclapi.cpp @@ -44,23 +44,23 @@ class opencl_initializer } void * opencl_library; cl_int (*clGetPlatformIDs) (cl_uint, cl_platform_id *, cl_uint *); - cl_int (*clGetPlatformInfo) (cl_platform_id, cl_platform_info, size_t, void *, size_t *); + cl_int (*clGetPlatformInfo) (cl_platform_id, cl_platform_info, std::size_t, void *, std::size_t *); cl_int (*clGetDeviceIDs) (cl_platform_id, cl_device_type, cl_uint, cl_device_id *, cl_uint *); - cl_int (*clGetDeviceInfo) (cl_device_id, cl_device_info, size_t, void *, size_t *); - cl_context (*clCreateContext) (cl_context_properties const *, cl_uint, cl_device_id const *, void (*) (const char *, const void *, size_t, void *), void *, cl_int *); + cl_int (*clGetDeviceInfo) (cl_device_id, cl_device_info, std::size_t, void *, std::size_t *); + cl_context (*clCreateContext) (cl_context_properties const *, cl_uint, cl_device_id const *, void (*) (char const *, const void *, std::size_t, void *), void *, cl_int *); cl_command_queue (*clCreateCommandQueue) (cl_context, cl_device_id, cl_command_queue_properties, cl_int *); - cl_mem (*clCreateBuffer) (cl_context, cl_mem_flags, size_t, void *, cl_int *); - cl_program (*clCreateProgramWithSource) (cl_context, cl_uint, char const **, size_t const *, cl_int *); + cl_mem (*clCreateBuffer) (cl_context, cl_mem_flags, std::size_t, void *, cl_int *); + cl_program (*clCreateProgramWithSource) (cl_context, cl_uint, char const **, std::size_t const *, cl_int *); cl_int (*clBuildProgram) (cl_program, cl_uint, cl_device_id const *, char const *, void (*) (cl_program, void *), void *); - cl_int (*clGetProgramBuildInfo) (cl_program, cl_device_id, cl_program_build_info, size_t, void *, size_t *); + cl_int (*clGetProgramBuildInfo) (cl_program, cl_device_id, cl_program_build_info, std::size_t, void *, std::size_t *); cl_kernel (*clCreateKernel) (cl_program, char const *, cl_int *); - cl_int (*clSetKernelArg) (cl_kernel, cl_uint, size_t, void const *); + cl_int (*clSetKernelArg) (cl_kernel, cl_uint, std::size_t, void const *); cl_int (*clReleaseKernel) (cl_kernel); cl_int (*clReleaseProgram) (cl_program); cl_int (*clReleaseContext) (cl_context); - cl_int (*clEnqueueWriteBuffer) (cl_command_queue, cl_mem, cl_bool, size_t, size_t, void const *, cl_uint, cl_event const *, cl_event *); - cl_int (*clEnqueueNDRangeKernel) (cl_command_queue, cl_kernel, cl_uint, size_t const *, size_t const *, size_t const *, cl_uint, cl_event const *, cl_event *); - cl_int (*clEnqueueReadBuffer) (cl_command_queue, cl_mem, cl_bool, size_t, size_t, void *, cl_uint, cl_event const *, cl_event *); + cl_int (*clEnqueueWriteBuffer) (cl_command_queue, cl_mem, cl_bool, std::size_t, std::size_t, void const *, cl_uint, cl_event const *, cl_event *); + cl_int (*clEnqueueNDRangeKernel) (cl_command_queue, cl_kernel, cl_uint, std::size_t const *, std::size_t const *, std::size_t const *, cl_uint, cl_event const *, cl_event *); + cl_int (*clEnqueueReadBuffer) (cl_command_queue, cl_mem, cl_bool, std::size_t, std::size_t, void *, cl_uint, cl_event const *, cl_event *); cl_int (*clFinish) (cl_command_queue); static opencl_initializer initializer; }; @@ -86,7 +86,7 @@ cl_int clGetPlatformIDs (cl_uint num_entries, cl_platform_id * platforms, cl_uin return result; } -cl_int clGetPlatformInfo (cl_platform_id platform, cl_platform_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret) +cl_int clGetPlatformInfo (cl_platform_id platform, cl_platform_info param_name, std::size_t param_value_size, void * param_value, std::size_t * param_value_size_ret) { return opencl_initializer::initializer.clGetPlatformInfo (platform, param_name, param_value_size, param_value, param_value_size_ret); } @@ -96,12 +96,12 @@ cl_int clGetDeviceIDs (cl_platform_id platform, cl_device_type device_type, cl_u return opencl_initializer::initializer.clGetDeviceIDs (platform, device_type, num_entries, devices, num_devices); } -cl_int clGetDeviceInfo (cl_device_id device, cl_device_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret) +cl_int clGetDeviceInfo (cl_device_id device, cl_device_info param_name, std::size_t param_value_size, void * param_value, std::size_t * param_value_size_ret) { return opencl_initializer::initializer.clGetDeviceInfo (device, param_name, param_value_size, param_value, param_value_size_ret); } -cl_context clCreateContext (cl_context_properties const * properties, cl_uint num_devices, cl_device_id const * devices, void (*pfn_notify) (const char *, const void *, size_t, void *), void * user_data, cl_int * errcode_ret) +cl_context clCreateContext (cl_context_properties const * properties, cl_uint num_devices, cl_device_id const * devices, void (*pfn_notify) (char const *, const void *, std::size_t, void *), void * user_data, cl_int * errcode_ret) { return opencl_initializer::initializer.clCreateContext (properties, num_devices, devices, pfn_notify, user_data, errcode_ret); } @@ -111,12 +111,12 @@ cl_command_queue clCreateCommandQueue (cl_context context, cl_device_id device, return opencl_initializer::initializer.clCreateCommandQueue (context, device, properties, errcode_ret); } -cl_mem clCreateBuffer (cl_context context, cl_mem_flags flags, size_t size, void * host_ptr, cl_int * errcode_ret) +cl_mem clCreateBuffer (cl_context context, cl_mem_flags flags, std::size_t size, void * host_ptr, cl_int * errcode_ret) { return opencl_initializer::initializer.clCreateBuffer (context, flags, size, host_ptr, errcode_ret); } -cl_program clCreateProgramWithSource (cl_context context, cl_uint count, char const ** strings, size_t const * lengths, cl_int * errcode_ret) +cl_program clCreateProgramWithSource (cl_context context, cl_uint count, char const ** strings, std::size_t const * lengths, cl_int * errcode_ret) { return opencl_initializer::initializer.clCreateProgramWithSource (context, count, strings, lengths, errcode_ret); } @@ -126,7 +126,7 @@ cl_int clBuildProgram (cl_program program, cl_uint num_devices, cl_device_id con return opencl_initializer::initializer.clBuildProgram (program, num_devices, device_list, options, pfn_notify, user_data); } -cl_int clGetProgramBuildInfo (cl_program program, cl_device_id device, cl_program_build_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret) +cl_int clGetProgramBuildInfo (cl_program program, cl_device_id device, cl_program_build_info param_name, std::size_t param_value_size, void * param_value, std::size_t * param_value_size_ret) { return opencl_initializer::initializer.clGetProgramBuildInfo (program, device, param_name, param_value_size, param_value, param_value_size_ret); } @@ -136,7 +136,7 @@ cl_kernel clCreateKernel (cl_program program, char const * kernel_name, cl_int * return opencl_initializer::initializer.clCreateKernel (program, kernel_name, errcode_ret); } -cl_int clSetKernelArg (cl_kernel kernel, cl_uint arg_index, size_t arg_size, void const * arg_value) +cl_int clSetKernelArg (cl_kernel kernel, cl_uint arg_index, std::size_t arg_size, void const * arg_value) { return opencl_initializer::initializer.clSetKernelArg (kernel, arg_index, arg_size, arg_value); } @@ -156,17 +156,17 @@ cl_int clReleaseContext (cl_context context) return opencl_initializer::initializer.clReleaseContext (context); } -cl_int clEnqueueWriteBuffer (cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, size_t offset, size_t size, void const * ptr, cl_uint num_events_in_wait_list, cl_event const * event_wait_list, cl_event * event) +cl_int clEnqueueWriteBuffer (cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, std::size_t offset, std::size_t size, void const * ptr, cl_uint num_events_in_wait_list, cl_event const * event_wait_list, cl_event * event) { return opencl_initializer::initializer.clEnqueueWriteBuffer (command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event); } -cl_int clEnqueueNDRangeKernel (cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim, size_t const * global_work_offset, size_t const * global_work_size, size_t const * local_work_size, cl_uint num_events_in_wait_list, cl_event const * event_wait_list, cl_event * event) +cl_int clEnqueueNDRangeKernel (cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim, std::size_t const * global_work_offset, std::size_t const * global_work_size, std::size_t const * local_work_size, cl_uint num_events_in_wait_list, cl_event const * event_wait_list, cl_event * event) { return opencl_initializer::initializer.clEnqueueNDRangeKernel (command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event); } -cl_int clEnqueueReadBuffer (cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, size_t offset, size_t size, void * ptr, cl_uint num_events_in_wait_list, cl_event const * event_wait_list, cl_event * event) +cl_int clEnqueueReadBuffer (cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, std::size_t offset, std::size_t size, void * ptr, cl_uint num_events_in_wait_list, cl_event const * event_wait_list, cl_event * event) { return opencl_initializer::initializer.clEnqueueReadBuffer (command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event); } diff --git a/nano/node/plat/windows/openclapi.cpp b/nano/node/plat/windows/openclapi.cpp index 290663a059..d164afd812 100644 --- a/nano/node/plat/windows/openclapi.cpp +++ b/nano/node/plat/windows/openclapi.cpp @@ -44,23 +44,23 @@ class opencl_initializer } HMODULE opencl_library; cl_int (CL_API_CALL * clGetPlatformIDs) (cl_uint, cl_platform_id *, cl_uint *); - cl_int (CL_API_CALL * clGetPlatformInfo) (cl_platform_id, cl_platform_info, size_t, void *, size_t *); + cl_int (CL_API_CALL * clGetPlatformInfo) (cl_platform_id, cl_platform_info, std::size_t, void *, std::size_t *); cl_int (CL_API_CALL * clGetDeviceIDs) (cl_platform_id, cl_device_type, cl_uint, cl_device_id *, cl_uint *); - cl_int (CL_API_CALL * clGetDeviceInfo) (cl_device_id, cl_device_info, size_t, void *, size_t *); - cl_context (CL_API_CALL * clCreateContext) (cl_context_properties const *, cl_uint, cl_device_id const *, void (CL_CALLBACK *) (const char *, const void *, size_t, void *), void *, cl_int *); + cl_int (CL_API_CALL * clGetDeviceInfo) (cl_device_id, cl_device_info, std::size_t, void *, std::size_t *); + cl_context (CL_API_CALL * clCreateContext) (cl_context_properties const *, cl_uint, cl_device_id const *, void (CL_CALLBACK *) (char const *, const void *, std::size_t, void *), void *, cl_int *); cl_command_queue (CL_API_CALL * clCreateCommandQueue) (cl_context, cl_device_id, cl_command_queue_properties, cl_int *); - cl_mem (CL_API_CALL * clCreateBuffer) (cl_context, cl_mem_flags, size_t, void *, cl_int *); - cl_program (CL_API_CALL * clCreateProgramWithSource) (cl_context, cl_uint, char const **, size_t const *, cl_int *); + cl_mem (CL_API_CALL * clCreateBuffer) (cl_context, cl_mem_flags, std::size_t, void *, cl_int *); + cl_program (CL_API_CALL * clCreateProgramWithSource) (cl_context, cl_uint, char const **, std::size_t const *, cl_int *); cl_int (CL_API_CALL * clBuildProgram) (cl_program, cl_uint, cl_device_id const *, char const *, void (CL_CALLBACK *) (cl_program, void *), void *); - cl_int (CL_API_CALL * clGetProgramBuildInfo) (cl_program, cl_device_id, cl_program_build_info, size_t, void *, size_t *); + cl_int (CL_API_CALL * clGetProgramBuildInfo) (cl_program, cl_device_id, cl_program_build_info, std::size_t, void *, std::size_t *); cl_kernel (CL_API_CALL * clCreateKernel) (cl_program, char const *, cl_int *); - cl_int (CL_API_CALL * clSetKernelArg) (cl_kernel, cl_uint, size_t, void const *); + cl_int (CL_API_CALL * clSetKernelArg) (cl_kernel, cl_uint, std::size_t, void const *); cl_int (CL_API_CALL * clReleaseKernel) (cl_kernel); cl_int (CL_API_CALL * clReleaseProgram) (cl_program); cl_int (CL_API_CALL * clReleaseContext) (cl_context); - cl_int (CL_API_CALL * clEnqueueWriteBuffer) (cl_command_queue, cl_mem, cl_bool, size_t, size_t, void const *, cl_uint, cl_event const *, cl_event *); - cl_int (CL_API_CALL * clEnqueueNDRangeKernel) (cl_command_queue, cl_kernel, cl_uint, size_t const *, size_t const *, size_t const *, cl_uint, cl_event const *, cl_event *); - cl_int (CL_API_CALL * clEnqueueReadBuffer) (cl_command_queue, cl_mem, cl_bool, size_t, size_t, void *, cl_uint, cl_event const *, cl_event *); + cl_int (CL_API_CALL * clEnqueueWriteBuffer) (cl_command_queue, cl_mem, cl_bool, std::size_t, std::size_t, void const *, cl_uint, cl_event const *, cl_event *); + cl_int (CL_API_CALL * clEnqueueNDRangeKernel) (cl_command_queue, cl_kernel, cl_uint, std::size_t const *, std::size_t const *, std::size_t const *, cl_uint, cl_event const *, cl_event *); + cl_int (CL_API_CALL * clEnqueueReadBuffer) (cl_command_queue, cl_mem, cl_bool, std::size_t, std::size_t, void *, cl_uint, cl_event const *, cl_event *); cl_int (CL_API_CALL * clFinish) (cl_command_queue); static opencl_initializer initializer; }; @@ -86,7 +86,7 @@ cl_int CL_API_CALL clGetPlatformIDs (cl_uint num_entries, cl_platform_id * platf return result; } -cl_int CL_API_CALL clGetPlatformInfo (cl_platform_id platform, cl_platform_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret) +cl_int CL_API_CALL clGetPlatformInfo (cl_platform_id platform, cl_platform_info param_name, std::size_t param_value_size, void * param_value, std::size_t * param_value_size_ret) { return opencl_initializer::initializer.clGetPlatformInfo (platform, param_name, param_value_size, param_value, param_value_size_ret); } @@ -96,12 +96,12 @@ cl_int CL_API_CALL clGetDeviceIDs (cl_platform_id platform, cl_device_type devic return opencl_initializer::initializer.clGetDeviceIDs (platform, device_type, num_entries, devices, num_devices); } -cl_int CL_API_CALL clGetDeviceInfo (cl_device_id device, cl_device_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret) +cl_int CL_API_CALL clGetDeviceInfo (cl_device_id device, cl_device_info param_name, std::size_t param_value_size, void * param_value, std::size_t * param_value_size_ret) { return opencl_initializer::initializer.clGetDeviceInfo (device, param_name, param_value_size, param_value, param_value_size_ret); } -cl_context CL_API_CALL clCreateContext (cl_context_properties const * properties, cl_uint num_devices, cl_device_id const * devices, void (CL_CALLBACK * pfn_notify) (const char *, const void *, size_t, void *), void * user_data, cl_int * errcode_ret) +cl_context CL_API_CALL clCreateContext (cl_context_properties const * properties, cl_uint num_devices, cl_device_id const * devices, void (CL_CALLBACK * pfn_notify) (char const *, const void *, std::size_t, void *), void * user_data, cl_int * errcode_ret) { return opencl_initializer::initializer.clCreateContext (properties, num_devices, devices, pfn_notify, user_data, errcode_ret); } @@ -111,12 +111,12 @@ cl_command_queue CL_API_CALL clCreateCommandQueue (cl_context context, cl_device return opencl_initializer::initializer.clCreateCommandQueue (context, device, properties, errcode_ret); } -cl_mem CL_API_CALL clCreateBuffer (cl_context context, cl_mem_flags flags, size_t size, void * host_ptr, cl_int * errcode_ret) +cl_mem CL_API_CALL clCreateBuffer (cl_context context, cl_mem_flags flags, std::size_t size, void * host_ptr, cl_int * errcode_ret) { return opencl_initializer::initializer.clCreateBuffer (context, flags, size, host_ptr, errcode_ret); } -cl_program CL_API_CALL clCreateProgramWithSource (cl_context context, cl_uint count, char const ** strings, size_t const * lengths, cl_int * errcode_ret) +cl_program CL_API_CALL clCreateProgramWithSource (cl_context context, cl_uint count, char const ** strings, std::size_t const * lengths, cl_int * errcode_ret) { return opencl_initializer::initializer.clCreateProgramWithSource (context, count, strings, lengths, errcode_ret); } @@ -126,7 +126,7 @@ cl_int CL_API_CALL clBuildProgram (cl_program program, cl_uint num_devices, cl_d return opencl_initializer::initializer.clBuildProgram (program, num_devices, device_list, options, pfn_notify, user_data); } -cl_int CL_API_CALL clGetProgramBuildInfo (cl_program program, cl_device_id device, cl_program_build_info param_name, size_t param_value_size, void * param_value, size_t * param_value_size_ret) +cl_int CL_API_CALL clGetProgramBuildInfo (cl_program program, cl_device_id device, cl_program_build_info param_name, std::size_t param_value_size, void * param_value, std::size_t * param_value_size_ret) { return opencl_initializer::initializer.clGetProgramBuildInfo (program, device, param_name, param_value_size, param_value, param_value_size_ret); } @@ -136,7 +136,7 @@ cl_kernel CL_API_CALL clCreateKernel (cl_program program, char const * kernel_na return opencl_initializer::initializer.clCreateKernel (program, kernel_name, errcode_ret); } -cl_int CL_API_CALL clSetKernelArg (cl_kernel kernel, cl_uint arg_index, size_t arg_size, void const * arg_value) +cl_int CL_API_CALL clSetKernelArg (cl_kernel kernel, cl_uint arg_index, std::size_t arg_size, void const * arg_value) { return opencl_initializer::initializer.clSetKernelArg (kernel, arg_index, arg_size, arg_value); } @@ -156,17 +156,17 @@ cl_int CL_API_CALL clReleaseContext (cl_context context) return opencl_initializer::initializer.clReleaseContext (context); } -cl_int CL_API_CALL clEnqueueWriteBuffer (cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, size_t offset, size_t size, void const * ptr, cl_uint num_events_in_wait_list, cl_event const * event_wait_list, cl_event * event) +cl_int CL_API_CALL clEnqueueWriteBuffer (cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_write, std::size_t offset, std::size_t size, void const * ptr, cl_uint num_events_in_wait_list, cl_event const * event_wait_list, cl_event * event) { return opencl_initializer::initializer.clEnqueueWriteBuffer (command_queue, buffer, blocking_write, offset, size, ptr, num_events_in_wait_list, event_wait_list, event); } -cl_int CL_API_CALL clEnqueueNDRangeKernel (cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim, size_t const * global_work_offset, size_t const * global_work_size, size_t const * local_work_size, cl_uint num_events_in_wait_list, cl_event const * event_wait_list, cl_event * event) +cl_int CL_API_CALL clEnqueueNDRangeKernel (cl_command_queue command_queue, cl_kernel kernel, cl_uint work_dim, std::size_t const * global_work_offset, std::size_t const * global_work_size, std::size_t const * local_work_size, cl_uint num_events_in_wait_list, cl_event const * event_wait_list, cl_event * event) { return opencl_initializer::initializer.clEnqueueNDRangeKernel (command_queue, kernel, work_dim, global_work_offset, global_work_size, local_work_size, num_events_in_wait_list, event_wait_list, event); } -cl_int CL_API_CALL clEnqueueReadBuffer (cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, size_t offset, size_t size, void * ptr, cl_uint num_events_in_wait_list, cl_event const * event_wait_list, cl_event * event) +cl_int CL_API_CALL clEnqueueReadBuffer (cl_command_queue command_queue, cl_mem buffer, cl_bool blocking_read, std::size_t offset, std::size_t size, void * ptr, cl_uint num_events_in_wait_list, cl_event const * event_wait_list, cl_event * event) { return opencl_initializer::initializer.clEnqueueReadBuffer (command_queue, buffer, blocking_read, offset, size, ptr, num_events_in_wait_list, event_wait_list, event); } diff --git a/nano/node/portmapping.cpp b/nano/node/portmapping.cpp index cd5bc92781..67b5629331 100644 --- a/nano/node/portmapping.cpp +++ b/nano/node/portmapping.cpp @@ -1,8 +1,8 @@ #include #include -#include -#include +#include +#include #include #include @@ -50,7 +50,7 @@ std::string nano::port_mapping::to_string () void nano::port_mapping::refresh_devices () { - if (!network_params.network.is_dev_network ()) + if (!node.network_params.network.is_dev_network ()) { upnp_state upnp_l; int discover_error_l = 0; @@ -96,7 +96,7 @@ nano::endpoint nano::port_mapping::external_address () void nano::port_mapping::refresh_mapping () { - debug_assert (!network_params.network.is_dev_network ()); + debug_assert (!node.network_params.network.is_dev_network ()); if (on) { nano::lock_guard guard_l (mutex); @@ -106,8 +106,8 @@ void nano::port_mapping::refresh_mapping () // We don't map the RPC port because, unless RPC authentication was added, this would almost always be a security risk for (auto & protocol : protocols | boost::adaptors::filtered ([] (auto const & p) { return p.enabled; })) { - auto upnp_description = std::string ("Banano Node (") + network_params.network.get_current_network_as_string () + ")"; - auto add_port_mapping_error_l (UPNP_AddPortMapping (upnp.urls.controlURL, upnp.data.first.servicetype, config_port_l.c_str (), node_port_l.c_str (), address.to_string ().c_str (), upnp_description.c_str (), protocol.name, nullptr, std::to_string (network_params.portmapping.lease_duration.count ()).c_str ())); + auto upnp_description = std::string ("Banano Node (") + node.network_params.network.get_current_network_as_string () + ")"; + auto add_port_mapping_error_l (UPNP_AddPortMapping (upnp.urls.controlURL, upnp.data.first.servicetype, config_port_l.c_str (), node_port_l.c_str (), address.to_string ().c_str (), upnp_description.c_str (), protocol.name, nullptr, std::to_string (node.network_params.portmapping.lease_duration.count ()).c_str ())); if (add_port_mapping_error_l == UPNPCOMMAND_SUCCESS) { @@ -128,7 +128,7 @@ void nano::port_mapping::refresh_mapping () bool nano::port_mapping::check_lost_or_old_mapping () { // Long discovery time and fast setup/teardown make this impractical for testing - debug_assert (!network_params.network.is_dev_network ()); + debug_assert (!node.network_params.network.is_dev_network ()); bool result_l (false); nano::lock_guard guard_l (mutex); auto node_port_l (std::to_string (node.network.endpoint ().port ())); @@ -141,7 +141,7 @@ bool nano::port_mapping::check_lost_or_old_mapping () remaining_mapping_duration_l.fill (0); auto verify_port_mapping_error_l (UPNP_GetSpecificPortMappingEntry (upnp.urls.controlURL, upnp.data.first.servicetype, config_port_l.c_str (), protocol.name, nullptr, int_client_l.data (), int_port_l.data (), nullptr, nullptr, remaining_mapping_duration_l.data ())); auto remaining_from_port_mapping = std::atoi (remaining_mapping_duration_l.data ()); - auto lease_duration = network_params.portmapping.lease_duration.count (); + auto lease_duration = node.network_params.portmapping.lease_duration.count (); auto lease_duration_divided_by_two = (lease_duration / 2); auto recent_lease = (remaining_from_port_mapping >= lease_duration_divided_by_two); if (verify_port_mapping_error_l != UPNPCOMMAND_SUCCESS) @@ -178,7 +178,7 @@ bool nano::port_mapping::check_lost_or_old_mapping () void nano::port_mapping::check_mapping_loop () { - auto health_check_period = network_params.portmapping.health_check_period; + auto health_check_period = node.network_params.portmapping.health_check_period; refresh_devices (); diff --git a/nano/node/portmapping.hpp b/nano/node/portmapping.hpp index f1dedc4906..7c355074fb 100644 --- a/nano/node/portmapping.hpp +++ b/nano/node/portmapping.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include #include @@ -58,7 +58,6 @@ class port_mapping std::string get_config_port (std::string const &); upnp_state upnp; nano::node & node; - nano::network_params network_params; boost::asio::ip::address_v4 address; std::array protocols; uint64_t check_count{ 0 }; diff --git a/nano/node/prioritization.cpp b/nano/node/prioritization.cpp index d0677a73d2..941204ef5a 100644 --- a/nano/node/prioritization.cpp +++ b/nano/node/prioritization.cpp @@ -26,7 +26,7 @@ void nano::prioritization::next () void nano::prioritization::seek () { next (); - for (size_t i = 0, n = schedule.size (); buckets[*current].empty () && i < n; ++i) + for (std::size_t i = 0, n = schedule.size (); buckets[*current].empty () && i < n; ++i) { next (); } @@ -44,7 +44,7 @@ nano::prioritization::prioritization (uint64_t maximum, std::function block); std::shared_ptr top () const; void pop (); - size_t size () const; - size_t bucket_count () const; - size_t bucket_size (size_t index) const; + std::size_t size () const; + std::size_t bucket_count () const; + std::size_t bucket_size (std::size_t index) const; bool empty () const; void dump (); uint64_t const maximum; diff --git a/nano/node/repcrawler.cpp b/nano/node/repcrawler.cpp index 9061f8f52a..d8e307fbd6 100644 --- a/nano/node/repcrawler.cpp +++ b/nano/node/repcrawler.cpp @@ -32,46 +32,76 @@ void nano::rep_crawler::validate () nano::lock_guard lock (active_mutex); responses_l.swap (responses); } - auto minimum = node.minimum_principal_weight (); + + // normally the rep_crawler only tracks principal reps but it can be made to track + // reps with less weight by setting rep_crawler_weight_minimum to a low value + auto minimum = std::min (node.minimum_principal_weight (), node.config.rep_crawler_weight_minimum.number ()); + for (auto const & i : responses_l) { auto & vote = i.second; auto & channel = i.first; debug_assert (channel != nullptr); - if (channel->get_type () != nano::transport::transport_type::loopback) + + if (channel->get_type () == nano::transport::transport_type::loopback) { - nano::uint128_t rep_weight = node.ledger.weight (vote->account); - if (rep_weight > minimum) + if (node.config.logging.rep_crawler_logging ()) { - auto updated_or_inserted = false; - nano::unique_lock lock (probable_reps_mutex); - auto existing (probable_reps.find (vote->account)); - if (existing != probable_reps.end ()) - { - probable_reps.modify (existing, [rep_weight, &updated_or_inserted, &vote, &channel] (nano::representative & info) { - info.last_response = std::chrono::steady_clock::now (); - - // Update if representative channel was changed - if (info.channel->get_endpoint () != channel->get_endpoint ()) - { - debug_assert (info.account == vote->account); - updated_or_inserted = true; - info.weight = rep_weight; - info.channel = channel; - } - }); - } - else - { - probable_reps.emplace (nano::representative (vote->account, rep_weight, channel)); - updated_or_inserted = true; - } - lock.unlock (); - if (updated_or_inserted) + node.logger.try_log (boost::str (boost::format ("rep_crawler ignoring vote from loopback channel %1%") % channel->to_string ())); + } + continue; + } + + nano::uint128_t rep_weight = node.ledger.weight (vote->account); + if (rep_weight < minimum) + { + if (node.config.logging.rep_crawler_logging ()) + { + node.logger.try_log (boost::str (boost::format ("rep_crawler ignoring vote from account %1% with too little voting weight %2%") % vote->account.to_account () % rep_weight)); + } + continue; + } + + // temporary data used for logging after dropping the lock + auto inserted = false; + auto updated = false; + std::shared_ptr prev_channel; + + nano::unique_lock lock (probable_reps_mutex); + + auto existing (probable_reps.find (vote->account)); + if (existing != probable_reps.end ()) + { + probable_reps.modify (existing, [rep_weight, &updated, &vote, &channel, &prev_channel] (nano::representative & info) { + info.last_response = std::chrono::steady_clock::now (); + + // Update if representative channel was changed + if (info.channel->get_endpoint () != channel->get_endpoint ()) { - node.logger.try_log (boost::str (boost::format ("Found a representative at %1%") % channel->to_string ())); + debug_assert (info.account == vote->account); + updated = true; + info.weight = rep_weight; + prev_channel = info.channel; + info.channel = channel; } - } + }); + } + else + { + probable_reps.emplace (nano::representative (vote->account, rep_weight, channel)); + inserted = true; + } + + lock.unlock (); + + if (inserted) + { + node.logger.try_log (boost::str (boost::format ("Found representative %1% at %2%") % vote->account.to_account () % channel->to_string ())); + } + + if (updated) + { + node.logger.try_log (boost::str (boost::format ("Updated representative %1% at %2% (was at: %3%)") % vote->account.to_account () % channel->to_string () % prev_channel->to_string ())); } } } @@ -91,7 +121,8 @@ void nano::rep_crawler::ongoing_crawl () node.keepalive_preconfigured (node.config.preconfigured_peers); } // Reduce crawl frequency when there's enough total peer weight - unsigned next_run_ms = node.network_params.network.is_dev_network () ? 100 : sufficient_weight ? 7000 : 3000; + unsigned next_run_ms = node.network_params.network.is_dev_network () ? 100 : sufficient_weight ? 7000 + : 3000; std::weak_ptr node_w (node.shared ()); node.workers.add_timed_task (now + std::chrono::milliseconds (next_run_ms), [node_w, this] () { if (auto node_l = node_w.lock ()) @@ -103,8 +134,8 @@ void nano::rep_crawler::ongoing_crawl () std::vector> nano::rep_crawler::get_crawl_targets (nano::uint128_t total_weight_a) { - constexpr size_t conservative_count = 10; - constexpr size_t aggressive_count = 40; + constexpr std::size_t conservative_count = 10; + constexpr std::size_t aggressive_count = 40; // Crawl more aggressively if we lack sufficient total peer weight. bool sufficient_weight (total_weight_a > node.online_reps.delta ()); @@ -324,9 +355,9 @@ void nano::rep_crawler::update_weights () } } -std::vector nano::rep_crawler::representatives (size_t count_a, nano::uint128_t const weight_a, boost::optional const & opt_version_min_a) +std::vector nano::rep_crawler::representatives (std::size_t count_a, nano::uint128_t const weight_a, boost::optional const & opt_version_min_a) { - auto version_min (opt_version_min_a.value_or (node.network_params.protocol.protocol_version_min ())); + auto version_min (opt_version_min_a.value_or (node.network_params.network.protocol_version_min)); std::vector result; nano::lock_guard lock (probable_reps_mutex); for (auto i (probable_reps.get ().begin ()), n (probable_reps.get ().end ()); i != n && result.size () < count_a; ++i) @@ -339,12 +370,12 @@ std::vector nano::rep_crawler::representatives (size_t cou return result; } -std::vector nano::rep_crawler::principal_representatives (size_t count_a, boost::optional const & opt_version_min_a) +std::vector nano::rep_crawler::principal_representatives (std::size_t count_a, boost::optional const & opt_version_min_a) { return representatives (count_a, node.minimum_principal_weight (), opt_version_min_a); } -std::vector> nano::rep_crawler::representative_endpoints (size_t count_a) +std::vector> nano::rep_crawler::representative_endpoints (std::size_t count_a) { std::vector> result; auto reps (representatives (count_a)); @@ -356,7 +387,7 @@ std::vector> nano::rep_crawler::repres } /** Total number of representatives */ -size_t nano::rep_crawler::representative_count () +std::size_t nano::rep_crawler::representative_count () { nano::lock_guard lock (probable_reps_mutex); return probable_reps.size (); diff --git a/nano/node/repcrawler.hpp b/nano/node/repcrawler.hpp index 678fe08b4f..7acd771b9f 100644 --- a/nano/node/repcrawler.hpp +++ b/nano/node/repcrawler.hpp @@ -41,7 +41,7 @@ class representative { return account == other_a.account; } - nano::account account{ 0 }; + nano::account account{}; nano::amount weight{ 0 }; std::shared_ptr channel; std::chrono::steady_clock::time_point last_request{ std::chrono::steady_clock::time_point () }; @@ -106,16 +106,16 @@ class rep_crawler final nano::uint128_t total_weight () const; /** Request a list of the top \p count_a known representatives in descending order of weight, with at least \p weight_a voting weight, and optionally with a minimum version \p opt_version_min_a */ - std::vector representatives (size_t count_a = std::numeric_limits::max (), nano::uint128_t const weight_a = 0, boost::optional const & opt_version_min_a = boost::none); + std::vector representatives (std::size_t count_a = std::numeric_limits::max (), nano::uint128_t const weight_a = 0, boost::optional const & opt_version_min_a = boost::none); /** Request a list of the top \p count_a known principal representatives in descending order of weight, optionally with a minimum version \p opt_version_min_a */ - std::vector principal_representatives (size_t count_a = std::numeric_limits::max (), boost::optional const & opt_version_min_a = boost::none); + std::vector principal_representatives (std::size_t count_a = std::numeric_limits::max (), boost::optional const & opt_version_min_a = boost::none); /** Request a list of the top \p count_a known representative endpoints. */ - std::vector> representative_endpoints (size_t count_a); + std::vector> representative_endpoints (std::size_t count_a); /** Total number of representatives */ - size_t representative_count (); + std::size_t representative_count (); private: nano::node & node; @@ -150,7 +150,7 @@ class rep_crawler final /** Probable representatives */ probably_rep_t probable_reps; - friend class active_transactions_confirm_active_Test; + friend class active_transactions_DISABLED_confirm_active_Test; friend class active_transactions_confirm_frontier_Test; friend class rep_crawler_local_Test; friend class node_online_reps_rep_crawler_Test; diff --git a/nano/node/request_aggregator.cpp b/nano/node/request_aggregator.cpp index b3f2ee7697..10c8250680 100644 --- a/nano/node/request_aggregator.cpp +++ b/nano/node/request_aggregator.cpp @@ -8,12 +8,13 @@ #include #include #include -#include #include +#include -nano::request_aggregator::request_aggregator (nano::network_constants const & network_constants_a, nano::node_config const & config_a, nano::stat & stats_a, nano::vote_generator & generator_a, nano::vote_generator & final_generator_a, nano::local_vote_history & history_a, nano::ledger & ledger_a, nano::wallets & wallets_a, nano::active_transactions & active_a) : - max_delay (network_constants_a.is_dev_network () ? 50 : 300), - small_delay (network_constants_a.is_dev_network () ? 10 : 50), +nano::request_aggregator::request_aggregator (nano::node_config const & config_a, nano::stat & stats_a, nano::vote_generator & generator_a, nano::vote_generator & final_generator_a, nano::local_vote_history & history_a, nano::ledger & ledger_a, nano::wallets & wallets_a, nano::active_transactions & active_a) : + config{ config_a }, + max_delay (config_a.network_params.network.is_dev_network () ? 50 : 300), + small_delay (config_a.network_params.network.is_dev_network () ? 10 : 50), max_channel_requests (config_a.max_queued_requests), stats (stats_a), local_votes (history_a), @@ -150,7 +151,7 @@ bool nano::request_aggregator::empty () void nano::request_aggregator::reply_action (std::shared_ptr const & vote_a, std::shared_ptr const & channel_a) const { - nano::confirm_ack confirm (vote_a); + nano::confirm_ack confirm{ config.network_params.network, vote_a }; channel_a->send (confirm); } @@ -168,7 +169,7 @@ void nano::request_aggregator::erase_duplicates (std::vector>, std::vector>> nano::request_aggregator::aggregate (std::vector> const & requests_a, std::shared_ptr & channel_a) const { auto transaction (ledger.store.tx_begin_read ()); - size_t cached_hashes = 0; + std::size_t cached_hashes = 0; std::vector> to_generate; std::vector> to_generate_final; std::vector> cached_votes; @@ -188,16 +189,16 @@ std::pair>, std::vector block; //2. Final votes - auto final_vote_hashes (ledger.store.final_vote_get (transaction, root)); + auto final_vote_hashes (ledger.store.final_vote.get (transaction, root)); if (!final_vote_hashes.empty ()) { generate_final_vote = true; - block = ledger.store.block_get (transaction, final_vote_hashes[0]); + block = ledger.store.block.get (transaction, final_vote_hashes[0]); // Allow same root vote if (block != nullptr && final_vote_hashes.size () > 1) { to_generate_final.push_back (block); - block = ledger.store.block_get (transaction, final_vote_hashes[1]); + block = ledger.store.block.get (transaction, final_vote_hashes[1]); debug_assert (final_vote_hashes.size () == 2); } } @@ -211,12 +212,12 @@ std::pair>, std::vectoraccount ().is_zero () ? block->sideband ().account : block->account (), confirmation_height_info); + ledger.store.confirmation_height.get (transaction, block->account ().is_zero () ? block->sideband ().account : block->account (), confirmation_height_info); generate_final_vote = (confirmation_height_info.height >= block->sideband ().height); } } @@ -225,13 +226,13 @@ std::pair>, std::vector>, std::vector>, std::vectoraccount ().is_zero () ? block->sideband ().account : block->account (), confirmation_height_info); + ledger.store.confirmation_height.get (transaction, block->account ().is_zero () ? block->sideband ().account : block->account (), confirmation_height_info); generate_final_vote = (confirmation_height_info.height >= block->sideband ().height); } } @@ -277,7 +278,7 @@ std::pair>, std::vectorhash () != hash) { - nano::publish publish (block); + nano::publish publish (config.network_params.network, block); channel_a->send (publish); } } diff --git a/nano/node/request_aggregator.hpp b/nano/node/request_aggregator.hpp index 52017cabb2..cc544bb9df 100644 --- a/nano/node/request_aggregator.hpp +++ b/nano/node/request_aggregator.hpp @@ -59,18 +59,19 @@ class request_aggregator final // clang-format on public: - request_aggregator (nano::network_constants const &, nano::node_config const & config, nano::stat & stats_a, nano::vote_generator &, nano::vote_generator &, nano::local_vote_history &, nano::ledger &, nano::wallets &, nano::active_transactions &); + request_aggregator (nano::node_config const & config, nano::stat & stats_a, nano::vote_generator &, nano::vote_generator &, nano::local_vote_history &, nano::ledger &, nano::wallets &, nano::active_transactions &); /** Add a new request by \p channel_a for hashes \p hashes_roots_a */ void add (std::shared_ptr const & channel_a, std::vector> const & hashes_roots_a); void stop (); /** Returns the number of currently queued request pools */ - size_t size (); + std::size_t size (); bool empty (); - const std::chrono::milliseconds max_delay; - const std::chrono::milliseconds small_delay; - const size_t max_channel_requests; + nano::node_config const & config; + std::chrono::milliseconds const max_delay; + std::chrono::milliseconds const small_delay; + std::size_t const max_channel_requests; private: void run (); @@ -104,7 +105,7 @@ class request_aggregator final nano::mutex mutex{ mutex_identifier (mutexes::request_aggregator) }; std::thread thread; - friend std::unique_ptr collect_container_info (request_aggregator &, const std::string &); + friend std::unique_ptr collect_container_info (request_aggregator &, std::string const &); }; -std::unique_ptr collect_container_info (request_aggregator &, const std::string &); +std::unique_ptr collect_container_info (request_aggregator &, std::string const &); } diff --git a/nano/node/rocksdb/rocksdb.cpp b/nano/node/rocksdb/rocksdb.cpp index a46bb3551c..983a2b3acd 100644 --- a/nano/node/rocksdb/rocksdb.cpp +++ b/nano/node/rocksdb/rocksdb.cpp @@ -45,26 +45,54 @@ void * rocksdb_val::data () const } template <> -size_t rocksdb_val::size () const +std::size_t rocksdb_val::size () const { return value.size (); } template <> -rocksdb_val::db_val (size_t size_a, void * data_a) : - value (static_cast (data_a), size_a) +rocksdb_val::db_val (std::size_t size_a, void * data_a) : + value (static_cast (data_a), size_a) { } template <> void rocksdb_val::convert_buffer_to_value () { - value = rocksdb::Slice (reinterpret_cast (buffer->data ()), buffer->size ()); -} -} - -nano::rocksdb_store::rocksdb_store (nano::logger_mt & logger_a, boost::filesystem::path const & path_a, nano::rocksdb_config const & rocksdb_config_a, bool open_read_only_a) : + value = rocksdb::Slice (reinterpret_cast (buffer->data ()), buffer->size ()); +} +} + +nano::rocksdb_store::rocksdb_store (nano::logger_mt & logger_a, boost::filesystem::path const & path_a, nano::ledger_constants & constants, nano::rocksdb_config const & rocksdb_config_a, bool open_read_only_a) : + // clang-format off + store_partial{ + constants, + block_store_partial, + frontier_store_partial, + account_store_partial, + pending_store_partial, + unchecked_rocksdb_store, + online_weight_store_partial, + pruned_store_partial, + peer_store_partial, + confirmation_height_store_partial, + final_vote_store_partial, + version_rocksdb_store + }, + // clang-format on + block_store_partial{ *this }, + frontier_store_partial{ *this }, + account_store_partial{ *this }, + pending_store_partial{ *this }, + unchecked_rocksdb_store{ *this }, + online_weight_store_partial{ *this }, + pruned_store_partial{ *this }, + peer_store_partial{ *this }, + confirmation_height_store_partial{ *this }, + final_vote_store_partial{ *this }, + version_rocksdb_store{ *this }, logger{ logger_a }, + constants{ constants }, rocksdb_config{ rocksdb_config_a }, max_block_write_batch_num_m{ nano::narrow_cast (blocks_memtable_size_bytes () / (2 * (sizeof (nano::block_type) + nano::state_block::size + nano::block_sideband::size (nano::block_type::state)))) }, cf_name_table_map{ create_cf_name_table_map () } @@ -86,9 +114,9 @@ nano::rocksdb_store::rocksdb_store (nano::logger_mt & logger_a, boost::filesyste } } -std::unordered_map nano::rocksdb_store::create_cf_name_table_map () const +std::unordered_map nano::rocksdb_store::create_cf_name_table_map () const { - std::unordered_map map{ { rocksdb::kDefaultColumnFamilyName.c_str (), tables::default_unused }, + std::unordered_map map{ { rocksdb::kDefaultColumnFamilyName.c_str (), tables::default_unused }, { "frontiers", tables::frontiers }, { "accounts", tables::accounts }, { "blocks", tables::blocks }, @@ -140,8 +168,8 @@ void nano::rocksdb_store::open (bool & error_a, boost::filesystem::path const & if (!error_a) { auto transaction = tx_begin_read (); - auto version_l = version_get (transaction); - if (version_l > version) + auto version_l = version.get (transaction); + if (version_l > version_number) { error_a = true; logger.always_log (boost::str (boost::format ("The version of the ledger (%1%) is too high for this node") % version_l)); @@ -329,7 +357,7 @@ std::string nano::rocksdb_store::vendor_get () const rocksdb::ColumnFamilyHandle * nano::rocksdb_store::table_to_column_family (tables table_a) const { auto & handles_l = handles; - auto get_handle = [&handles_l] (const char * name) { + auto get_handle = [&handles_l] (char const * name) { auto iter = std::find_if (handles_l.begin (), handles_l.end (), [name] (auto & handle) { return (handle->GetName () == name); }); @@ -416,13 +444,13 @@ void nano::rocksdb_store::flush_table (nano::tables table_a) db->Flush (rocksdb::FlushOptions{}, table_to_column_family (table_a)); } -void nano::rocksdb_store::version_put (nano::write_transaction const & transaction_a, int version_a) +void nano::version_rocksdb_store::version_put (nano::write_transaction const & transaction_a, int version_a) { debug_assert (transaction_a.contains (tables::meta)); nano::uint256_union version_key (1); nano::uint256_union version_value (version_a); - auto status (put (transaction_a, tables::meta, version_key, nano::rocksdb_val (version_value))); - release_assert (success (status)); + auto status (rocksdb_store.put (transaction_a, tables::meta, version_key, nano::rocksdb_val (version_value))); + release_assert (rocksdb_store.success (status)); } rocksdb::Transaction * nano::rocksdb_store::tx (nano::transaction const & transaction_a) const @@ -483,14 +511,14 @@ uint64_t nano::rocksdb_store::count (nano::transaction const & transaction_a, ta // Peers/online weight are small enough that they can just be iterated to get accurate counts. if (table_a == tables::peers) { - for (auto i (peers_begin (transaction_a)), n (peers_end ()); i != n; ++i) + for (auto i (peer.begin (transaction_a)), n (peer.end ()); i != n; ++i) { ++sum; } } else if (table_a == tables::online_weight) { - for (auto i (online_weight_begin (transaction_a)), n (online_weight_end ()); i != n; ++i) + for (auto i (online_weight.begin (transaction_a)), n (online_weight.end ()); i != n; ++i) { ++sum; } @@ -514,8 +542,7 @@ uint64_t nano::rocksdb_store::count (nano::transaction const & transaction_a, ta // otherwise there can be performance issues. else if (table_a == tables::accounts) { - debug_assert (network_constants ().is_dev_network ()); - for (auto i (accounts_begin (transaction_a)), n (accounts_end ()); i != n; ++i) + for (auto i (account.begin (transaction_a)), n (account.end ()); i != n; ++i) { ++sum; } @@ -523,15 +550,14 @@ uint64_t nano::rocksdb_store::count (nano::transaction const & transaction_a, ta else if (table_a == tables::blocks) { // This is also used in some CLI commands - for (auto i (blocks_begin (transaction_a)), n (blocks_end ()); i != n; ++i) + for (auto i (block.begin (transaction_a)), n (block.end ()); i != n; ++i) { ++sum; } } else if (table_a == tables::confirmation_height) { - debug_assert (network_constants ().is_dev_network ()); - for (auto i (confirmation_height_begin (transaction_a)), n (confirmation_height_end ()); i != n; ++i) + for (auto i (confirmation_height.begin (transaction_a)), n (confirmation_height.end ()); i != n; ++i) { ++sum; } @@ -557,7 +583,7 @@ int nano::rocksdb_store::drop (nano::write_transaction const & transaction_a, ta if (table_a == tables::peers) { int status = 0; - for (auto i = peers_begin (transaction_a), n = peers_end (); i != n; ++i) + for (auto i = peer.begin (transaction_a), n = peer.end (); i != n; ++i) { status = del (transaction_a, tables::peers, nano::rocksdb_val (i->first)); release_assert (success (status)); @@ -590,9 +616,17 @@ int nano::rocksdb_store::clear (rocksdb::ColumnFamilyHandle * column_family) return status.code (); } -std::vector nano::rocksdb_store::unchecked_get (nano::transaction const & transaction_a, nano::block_hash const & hash_a) +nano::unchecked_rocksdb_store::unchecked_rocksdb_store (nano::rocksdb_store & rocksdb_store_a) : + nano::unchecked_store_partial (rocksdb_store_a), + rocksdb_store{ rocksdb_store_a } {}; + +nano::version_rocksdb_store::version_rocksdb_store (nano::rocksdb_store & rocksdb_store_a) : + nano::version_store_partial (rocksdb_store_a), + rocksdb_store{ rocksdb_store_a } {}; + +std::vector nano::unchecked_rocksdb_store::get (nano::transaction const & transaction_a, nano::block_hash const & hash_a) { - auto cf = table_to_column_family (tables::unchecked); + auto cf = rocksdb_store.table_to_column_family (tables::unchecked); std::unique_ptr iter; nano::qualified_root upper (hash_a, nano::block_hash (std::numeric_limits::max ())); @@ -604,7 +638,7 @@ std::vector nano::rocksdb_store::unchecked_get (nano::tran read_options.auto_prefix_mode = true; read_options.iterate_upper_bound = upper_bound; read_options.fill_cache = false; - iter.reset (db->NewIterator (read_options, cf)); + iter.reset (rocksdb_store.db->NewIterator (read_options, cf)); } else { @@ -613,7 +647,7 @@ std::vector nano::rocksdb_store::unchecked_get (nano::tran read_options.auto_prefix_mode = true; read_options.iterate_upper_bound = upper_bound; read_options.fill_cache = false; - iter.reset (tx (transaction_a)->GetIterator (read_options, cf)); + iter.reset (rocksdb_store.tx (transaction_a)->GetIterator (read_options, cf)); } // Uses prefix extraction @@ -675,7 +709,7 @@ rocksdb::Options nano::rocksdb_store::get_db_options () return db_options; } -rocksdb::BlockBasedTableOptions nano::rocksdb_store::get_active_table_options (size_t lru_size) const +rocksdb::BlockBasedTableOptions nano::rocksdb_store::get_active_table_options (std::size_t lru_size) const { rocksdb::BlockBasedTableOptions table_options; @@ -822,7 +856,7 @@ bool nano::rocksdb_store::copy_db (boost::filesystem::path const & destination_p // Open it so that it flushes all WAL files if (status.ok ()) { - nano::rocksdb_store rocksdb_store (logger, destination_path.string (), rocksdb_config, false); + nano::rocksdb_store rocksdb_store (logger, destination_path.string (), constants, rocksdb_config, false); return !rocksdb_store.init_error (); } return false; @@ -913,4 +947,4 @@ nano::rocksdb_store::tombstone_info::tombstone_info (uint64_t num_since_last_flu } // Explicitly instantiate -template class nano::block_store_partial; +template class nano::store_partial; diff --git a/nano/node/rocksdb/rocksdb.hpp b/nano/node/rocksdb/rocksdb.hpp index 6a5ab11571..0c05aceed5 100644 --- a/nano/node/rocksdb/rocksdb.hpp +++ b/nano/node/rocksdb/rocksdb.hpp @@ -4,8 +4,18 @@ #include #include #include -#include #include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include #include #include @@ -19,22 +29,58 @@ namespace nano { class logging_mt; class rocksdb_config; +class rocksdb_store; + +class unchecked_rocksdb_store : public unchecked_store_partial +{ +public: + explicit unchecked_rocksdb_store (nano::rocksdb_store &); + std::vector get (nano::transaction const &, nano::block_hash const &); + +private: + nano::rocksdb_store & rocksdb_store; +}; + +class version_rocksdb_store : public version_store_partial +{ +public: + explicit version_rocksdb_store (nano::rocksdb_store &); + void version_put (nano::write_transaction const &, int); + +private: + nano::rocksdb_store & rocksdb_store; +}; /** * rocksdb implementation of the block store */ -class rocksdb_store : public block_store_partial +class rocksdb_store : public store_partial { +private: + nano::block_store_partial block_store_partial; + nano::frontier_store_partial frontier_store_partial; + nano::account_store_partial account_store_partial; + nano::pending_store_partial pending_store_partial; + nano::unchecked_rocksdb_store unchecked_rocksdb_store; + nano::online_weight_store_partial online_weight_store_partial; + nano::pruned_store_partial pruned_store_partial; + nano::peer_store_partial peer_store_partial; + nano::confirmation_height_store_partial confirmation_height_store_partial; + nano::final_vote_store_partial final_vote_store_partial; + nano::version_rocksdb_store version_rocksdb_store; + public: - rocksdb_store (nano::logger_mt &, boost::filesystem::path const &, nano::rocksdb_config const & = nano::rocksdb_config{}, bool open_read_only = false); + friend class nano::unchecked_rocksdb_store; + friend class nano::version_rocksdb_store; + + explicit rocksdb_store (nano::logger_mt &, boost::filesystem::path const &, nano::ledger_constants & constants, nano::rocksdb_config const & = nano::rocksdb_config{}, bool open_read_only = false); + nano::write_transaction tx_begin_write (std::vector const & tables_requiring_lock = {}, std::vector const & tables_no_lock = {}) override; nano::read_transaction tx_begin_read () const override; std::string vendor_get () const override; uint64_t count (nano::transaction const & transaction_a, tables table_a) const override; - void version_put (nano::write_transaction const &, int) override; - std::vector unchecked_get (nano::transaction const & transaction_a, nano::block_hash const & hash_a) override; bool exists (nano::transaction const & transaction_a, tables table_a, nano::rocksdb_val const & key_a) const; int get (nano::transaction const & transaction_a, tables table_a, nano::rocksdb_val const & key_a, nano::rocksdb_val & value_a) const; @@ -67,6 +113,7 @@ class rocksdb_store : public block_store_partial private: bool error{ false }; nano::logger_mt & logger; + nano::ledger_constants & constants; // Optimistic transactions are used in write mode rocksdb::OptimisticTransactionDB * optimistic_db = nullptr; std::unique_ptr db; @@ -85,7 +132,7 @@ class rocksdb_store : public block_store_partial }; std::unordered_map tombstone_map; - std::unordered_map cf_name_table_map; + std::unordered_map cf_name_table_map; rocksdb::Transaction * tx (nano::transaction const & transaction_a) const; std::vector all_tables () const; @@ -105,7 +152,7 @@ class rocksdb_store : public block_store_partial rocksdb::ColumnFamilyOptions get_common_cf_options (std::shared_ptr const & table_factory_a, unsigned long long memtable_size_bytes_a) const; rocksdb::ColumnFamilyOptions get_active_cf_options (std::shared_ptr const & table_factory_a, unsigned long long memtable_size_bytes_a) const; rocksdb::ColumnFamilyOptions get_small_cf_options (std::shared_ptr const & table_factory_a) const; - rocksdb::BlockBasedTableOptions get_active_table_options (size_t lru_size) const; + rocksdb::BlockBasedTableOptions get_active_table_options (std::size_t lru_size) const; rocksdb::BlockBasedTableOptions get_small_table_options () const; rocksdb::ColumnFamilyOptions get_cf_options (std::string const & cf_name_a) const; @@ -113,7 +160,7 @@ class rocksdb_store : public block_store_partial void flush_table (nano::tables table_a); void flush_tombstones_check (nano::tables table_a); void generate_tombstone_map (); - std::unordered_map create_cf_name_table_map () const; + std::unordered_map create_cf_name_table_map () const; std::vector create_column_families (); unsigned long long base_memtable_size_bytes () const; @@ -125,5 +172,5 @@ class rocksdb_store : public block_store_partial friend class rocksdb_block_store_tombstone_count_Test; }; -extern template class block_store_partial; +extern template class store_partial; } diff --git a/nano/node/rocksdb/rocksdb_iterator.hpp b/nano/node/rocksdb/rocksdb_iterator.hpp index 263e910b69..2633dcf763 100644 --- a/nano/node/rocksdb/rocksdb_iterator.hpp +++ b/nano/node/rocksdb/rocksdb_iterator.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include #include #include @@ -13,7 +13,7 @@ namespace { inline bool is_read (nano::transaction const & transaction_a) { - return (dynamic_cast (&transaction_a) != nullptr); + return (dynamic_cast (&transaction_a) != nullptr); } inline rocksdb::ReadOptions & snapshot_options (nano::transaction const & transaction_a) diff --git a/nano/node/rocksdb/rocksdb_txn.hpp b/nano/node/rocksdb/rocksdb_txn.hpp index 14b8565c71..ff17a96999 100644 --- a/nano/node/rocksdb/rocksdb_txn.hpp +++ b/nano/node/rocksdb/rocksdb_txn.hpp @@ -1,6 +1,6 @@ #pragma once -#include +#include #include #include diff --git a/nano/node/signatures.cpp b/nano/node/signatures.cpp index a8b21fa771..4af3c2db06 100644 --- a/nano/node/signatures.cpp +++ b/nano/node/signatures.cpp @@ -32,8 +32,8 @@ void nano::signature_checker::verify (nano::signature_check_set & check_a) // Split up the tasks equally over the calling thread and the thread pool. // Any overflow on the modulus of the batch_size is given to the calling thread, so the thread pool // only ever operates on batch_size sizes. - size_t overflow_size = check_a.size % batch_size; - size_t num_full_batches = check_a.size / batch_size; + std::size_t overflow_size = check_a.size % batch_size; + std::size_t num_full_batches = check_a.size / batch_size; auto const num_threads = thread_pool.get_num_threads (); auto total_threads_to_split_over = num_threads + 1; @@ -86,7 +86,7 @@ void nano::signature_checker::flush () ; } -bool nano::signature_checker::verify_batch (const nano::signature_check_set & check_a, size_t start_index, size_t size) +bool nano::signature_checker::verify_batch (nano::signature_check_set const & check_a, std::size_t start_index, std::size_t size) { nano::validate_message_batch (check_a.messages + start_index, check_a.message_lengths + start_index, check_a.pub_keys + start_index, check_a.signatures + start_index, size, check_a.verifications + start_index); return std::all_of (check_a.verifications + start_index, check_a.verifications + start_index + size, [] (int verification) { return verification == 0 || verification == 1; }); @@ -95,12 +95,12 @@ bool nano::signature_checker::verify_batch (const nano::signature_check_set & ch /* This operates on a number of signatures of size (num_batches * batch_size) from the beginning of the check_a pointers. * Caller should check the value of the promise which indicates when the work has been completed. */ -void nano::signature_checker::verify_async (nano::signature_check_set & check_a, size_t num_batches, std::promise & promise) +void nano::signature_checker::verify_async (nano::signature_check_set & check_a, std::size_t num_batches, std::promise & promise) { auto task = std::make_shared (check_a, num_batches); ++tasks_remaining; - for (size_t batch = 0; batch < num_batches; ++batch) + for (std::size_t batch = 0; batch < num_batches; ++batch) { auto size = batch_size; auto start_index = batch * batch_size; diff --git a/nano/node/signatures.hpp b/nano/node/signatures.hpp index 5cda22c7e7..eb3e3294dc 100644 --- a/nano/node/signatures.hpp +++ b/nano/node/signatures.hpp @@ -12,14 +12,14 @@ namespace nano class signature_check_set final { public: - signature_check_set (size_t size, unsigned char const ** messages, size_t * message_lengths, unsigned char const ** pub_keys, unsigned char const ** signatures, int * verifications) : + signature_check_set (std::size_t size, unsigned char const ** messages, std::size_t * message_lengths, unsigned char const ** pub_keys, unsigned char const ** signatures, int * verifications) : size (size), messages (messages), message_lengths (message_lengths), pub_keys (pub_keys), signatures (signatures), verifications (verifications) { } - size_t size; + std::size_t size; unsigned char const ** messages; - size_t * message_lengths; + std::size_t * message_lengths; unsigned char const ** pub_keys; unsigned char const ** signatures; int * verifications; @@ -35,7 +35,7 @@ class signature_checker final void stop (); void flush (); - static size_t constexpr batch_size = 256; + static std::size_t constexpr batch_size = 256; private: std::atomic tasks_remaining{ 0 }; @@ -44,7 +44,7 @@ class signature_checker final struct Task final { - Task (nano::signature_check_set & check, size_t pending) : + Task (nano::signature_check_set & check, std::size_t pending) : check (check), pending (pending) { } @@ -53,11 +53,11 @@ class signature_checker final release_assert (pending == 0); } nano::signature_check_set & check; - std::atomic pending; + std::atomic pending; }; - bool verify_batch (const nano::signature_check_set & check_a, size_t index, size_t size); - void verify_async (nano::signature_check_set & check_a, size_t num_batches, std::promise & promise); + bool verify_batch (nano::signature_check_set const & check_a, std::size_t index, std::size_t size); + void verify_async (nano::signature_check_set & check_a, std::size_t num_batches, std::promise & promise); bool single_threaded () const; }; } diff --git a/nano/node/socket.cpp b/nano/node/socket.cpp index 0eebccbf12..64495f6c85 100644 --- a/nano/node/socket.cpp +++ b/nano/node/socket.cpp @@ -1,25 +1,31 @@ #include #include +#include +#include +#include #include #include #include +#include #include +#include +#include #include +#include -nano::socket::socket (nano::node & node_a, boost::optional io_timeout_a) : +nano::socket::socket (nano::node & node_a, endpoint_type_t endpoint_type_a) : strand{ node_a.io_ctx.get_executor () }, tcp_socket{ node_a.io_ctx }, node{ node_a }, + endpoint_type_m{ endpoint_type_a }, next_deadline{ std::numeric_limits::max () }, - last_completion_time{ 0 }, - io_timeout{ io_timeout_a } + last_completion_time_or_init{ nano::seconds_since_epoch () }, + last_receive_time_or_init{ nano::seconds_since_epoch () }, + io_timeout{ node_a.config.tcp_io_timeout }, + silent_connection_tolerance_time{ node_a.network_params.network.silent_connection_tolerance_time } { - if (!io_timeout) - { - io_timeout = node_a.config.tcp_io_timeout; - } } nano::socket::~socket () @@ -29,6 +35,7 @@ nano::socket::~socket () void nano::socket::async_connect (nano::tcp_endpoint const & endpoint_a, std::function callback_a) { + debug_assert (endpoint_type () == endpoint_type_t::client); checkup (); auto this_l (shared_from_this ()); start_timer (); @@ -41,7 +48,7 @@ void nano::socket::async_connect (nano::tcp_endpoint const & endpoint_a, std::fu })); } -void nano::socket::async_read (std::shared_ptr> const & buffer_a, size_t size_a, std::function callback_a) +void nano::socket::async_read (std::shared_ptr> const & buffer_a, std::size_t size_a, std::function callback_a) { if (size_a <= buffer_a->size ()) { @@ -52,9 +59,10 @@ void nano::socket::async_read (std::shared_ptr> const & buf boost::asio::post (strand, boost::asio::bind_executor (strand, [buffer_a, callback_a, size_a, this_l] () { boost::asio::async_read (this_l->tcp_socket, boost::asio::buffer (buffer_a->data (), size_a), boost::asio::bind_executor (this_l->strand, - [this_l, buffer_a, callback_a] (boost::system::error_code const & ec, size_t size_a) { + [this_l, buffer_a, callback_a] (boost::system::error_code const & ec, std::size_t size_a) { this_l->node.stats.add (nano::stat::type::traffic_tcp, nano::stat::dir::in, size_a); this_l->stop_timer (); + this_l->update_last_receive_time (); callback_a (ec, size_a); })); })); @@ -68,7 +76,7 @@ void nano::socket::async_read (std::shared_ptr> const & buf } } -void nano::socket::async_write (nano::shared_const_buffer const & buffer_a, std::function const & callback_a) +void nano::socket::async_write (nano::shared_const_buffer const & buffer_a, std::function const & callback_a) { if (!closed) { @@ -108,7 +116,7 @@ void nano::socket::async_write (nano::shared_const_buffer const & buffer_a, std: void nano::socket::start_timer () { - start_timer (io_timeout.get ()); + start_timer (io_timeout); } void nano::socket::start_timer (std::chrono::seconds deadline_a) @@ -118,17 +126,34 @@ void nano::socket::start_timer (std::chrono::seconds deadline_a) void nano::socket::stop_timer () { - last_completion_time = nano::seconds_since_epoch (); + last_completion_time_or_init = nano::seconds_since_epoch (); +} + +void nano::socket::update_last_receive_time () +{ + last_receive_time_or_init = nano::seconds_since_epoch (); } void nano::socket::checkup () { std::weak_ptr this_w (shared_from_this ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (node.network_params.network.is_dev_network () ? 1 : 2), [this_w] () { + node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (2), [this_w] () { if (auto this_l = this_w.lock ()) { uint64_t now (nano::seconds_since_epoch ()); - if (this_l->next_deadline != std::numeric_limits::max () && now - this_l->last_completion_time > this_l->next_deadline) + auto condition_to_disconnect{ false }; + if (this_l->endpoint_type () == endpoint_type_t::server && (now - this_l->last_receive_time_or_init) > this_l->silent_connection_tolerance_time.count ()) + { + this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_silent_connection_drop, nano::stat::dir::in); + condition_to_disconnect = true; + } + if (this_l->next_deadline != std::numeric_limits::max () && (now - this_l->last_completion_time_or_init) > this_l->next_deadline) + { + this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_io_timeout_drop, + this_l->endpoint_type () == endpoint_type_t::server ? nano::stat::dir::in : nano::stat::dir::out); + condition_to_disconnect = true; + } + if (condition_to_disconnect) { if (this_l->node.config.logging.network_timeout_logging ()) { @@ -156,11 +181,16 @@ bool nano::socket::has_timed_out () const return timed_out; } -void nano::socket::set_timeout (std::chrono::seconds io_timeout_a) +void nano::socket::timeout_set (std::chrono::seconds io_timeout_a) +{ + io_timeout = io_timeout_a; +} + +void nano::socket::set_silent_connection_tolerance_time (std::chrono::seconds tolerance_time_a) { auto this_l (shared_from_this ()); - boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l, io_timeout_a] () { - this_l->io_timeout = io_timeout_a; + boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l, tolerance_time_a] () { + this_l->silent_connection_tolerance_time = tolerance_time_a; })); } @@ -177,7 +207,7 @@ void nano::socket::close_internal () { if (!closed.exchange (true)) { - io_timeout = boost::none; + io_timeout = std::chrono::seconds (0); boost::system::error_code ec; // Ignore error code for shutdown as it is best-effort @@ -196,12 +226,18 @@ nano::tcp_endpoint nano::socket::remote_endpoint () const return remote; } -nano::server_socket::server_socket (nano::node & node_a, boost::asio::ip::tcp::endpoint local_a, size_t max_connections_a) : - socket{ node_a, std::chrono::seconds::max () }, +nano::tcp_endpoint nano::socket::local_endpoint () const +{ + return tcp_socket.local_endpoint (); +} + +nano::server_socket::server_socket (nano::node & node_a, boost::asio::ip::tcp::endpoint local_a, std::size_t max_connections_a) : + socket{ node_a, endpoint_type_t::server }, acceptor{ node_a.io_ctx }, local{ local_a }, max_inbound_connections{ max_connections_a } { + io_timeout = std::chrono::seconds::max (); } void nano::server_socket::start (boost::system::error_code & ec_a) @@ -222,17 +258,81 @@ void nano::server_socket::close () boost::asio::dispatch (strand, boost::asio::bind_executor (strand, [this_l] () { this_l->close_internal (); this_l->acceptor.close (); - for (auto & connection_w : this_l->connections) + for (auto & address_connection_pair : this_l->connections_per_address) { - if (auto connection_l = connection_w.lock ()) + if (auto connection_l = address_connection_pair.second.lock ()) { connection_l->close (); } } - this_l->connections.clear (); + this_l->connections_per_address.clear (); })); } +boost::asio::ip::network_v6 nano::socket_functions::get_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix) +{ + return boost::asio::ip::make_network_v6 (ip_address, network_prefix); +} + +boost::asio::ip::address nano::socket_functions::first_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix) +{ + auto range = get_ipv6_subnet_address (ip_address, network_prefix).hosts (); + debug_assert (!range.empty ()); + return *(range.begin ()); +} + +boost::asio::ip::address nano::socket_functions::last_ipv6_subnet_address (boost::asio::ip::address_v6 const & ip_address, size_t network_prefix) +{ + auto range = get_ipv6_subnet_address (ip_address, network_prefix).hosts (); + debug_assert (!range.empty ()); + return *(--range.end ()); +} + +size_t nano::socket_functions::count_subnetwork_connections ( +nano::address_socket_mmap const & per_address_connections, +boost::asio::ip::address_v6 const & remote_address, +size_t network_prefix) +{ + auto range = get_ipv6_subnet_address (remote_address, network_prefix).hosts (); + if (range.empty ()) + { + return 0; + } + auto const first_ip = first_ipv6_subnet_address (remote_address, network_prefix); + auto const last_ip = last_ipv6_subnet_address (remote_address, network_prefix); + auto const counted_connections = std::distance (per_address_connections.lower_bound (first_ip), per_address_connections.upper_bound (last_ip)); + return counted_connections; +} + +bool nano::server_socket::limit_reached_for_incoming_subnetwork_connections (std::shared_ptr const & new_connection) +{ + debug_assert (strand.running_in_this_thread ()); + if (node.flags.disable_max_peers_per_subnetwork || nano::transport::is_ipv4_or_v4_mapped_address (new_connection->remote.address ())) + { + // If the limit is disabled, then it is unreachable. + // If the address is IPv4 we don't check for a network limit, since its address space isn't big as IPv6 /64. + return false; + } + auto const counted_connections = socket_functions::count_subnetwork_connections ( + connections_per_address, + new_connection->remote.address ().to_v6 (), + node.network_params.network.ipv6_subnetwork_prefix_for_limiting); + return counted_connections >= node.network_params.network.max_peers_per_subnetwork; +} + +bool nano::server_socket::limit_reached_for_incoming_ip_connections (std::shared_ptr const & new_connection) +{ + debug_assert (strand.running_in_this_thread ()); + if (node.flags.disable_max_peers_per_ip) + { + // If the limit is disabled, then it is unreachable. + return false; + } + auto const address_connections_range = connections_per_address.equal_range (new_connection->remote.address ()); + auto const counted_connections = std::distance (address_connections_range.first, address_connections_range.second); + return counted_connections >= node.network_params.network.max_peers_per_ip; +} + void nano::server_socket::on_connection (std::function const &, boost::system::error_code const &)> callback_a) { auto this_l (std::static_pointer_cast (shared_from_this ())); @@ -245,28 +345,55 @@ void nano::server_socket::on_connection (std::function (this_l->node, boost::none); + auto new_connection = std::make_shared (this_l->node, endpoint_type_t::server); this_l->acceptor.async_accept (new_connection->tcp_socket, new_connection->remote, boost::asio::bind_executor (this_l->strand, [this_l, new_connection, callback_a] (boost::system::error_code const & ec_a) { this_l->evict_dead_connections (); - if (this_l->connections.size () >= this_l->max_inbound_connections) + if (this_l->connections_per_address.size () >= this_l->max_inbound_connections) { - this_l->node.logger.always_log ("Network: max_inbound_connections reached, unable to open new connection"); + this_l->node.logger.try_log ("Network: max_inbound_connections reached, unable to open new connection"); this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_accept_failure, nano::stat::dir::in); this_l->on_connection_requeue_delayed (callback_a); return; } + if (this_l->limit_reached_for_incoming_ip_connections (new_connection)) + { + auto const remote_ip_address = new_connection->remote_endpoint ().address (); + auto const log_message = boost::str ( + boost::format ("Network: max connections per IP (max_peers_per_ip) was reached for %1%, unable to open new connection") + % remote_ip_address.to_string ()); + this_l->node.logger.try_log (log_message); + this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_max_per_ip, nano::stat::dir::in); + this_l->on_connection_requeue_delayed (callback_a); + return; + } + + if (this_l->limit_reached_for_incoming_subnetwork_connections (new_connection)) + { + auto const remote_ip_address = new_connection->remote_endpoint ().address (); + debug_assert (remote_ip_address.is_v6 ()); + auto const remote_subnet = socket_functions::get_ipv6_subnet_address (remote_ip_address.to_v6 (), this_l->node.network_params.network.max_peers_per_subnetwork); + auto const log_message = boost::str ( + boost::format ("Network: max connections per subnetwork (max_peers_per_subnetwork) was reached for subnetwork %1% (remote IP: %2%), unable to open new connection") + % remote_subnet.canonical ().to_string () + % remote_ip_address.to_string ()); + this_l->node.logger.try_log (log_message); + this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_max_per_subnetwork, nano::stat::dir::in); + this_l->on_connection_requeue_delayed (callback_a); + return; + } + if (!ec_a) { // Make sure the new connection doesn't idle. Note that in most cases, the callback is going to start // an IO operation immediately, which will start a timer. new_connection->checkup (); - new_connection->start_timer (this_l->node.network_params.network.is_dev_network () ? std::chrono::seconds (2) : this_l->node.network_params.node.idle_timeout); + new_connection->start_timer (this_l->node.network_params.network.is_dev_network () ? this_l->node.network_params.network.socket_dev_idle_timeout : this_l->node.network_params.network.idle_timeout); this_l->node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_accept_success, nano::stat::dir::in); - this_l->connections.push_back (new_connection); + this_l->connections_per_address.emplace (new_connection->remote.address (), new_connection); if (callback_a (new_connection, ec_a)) { this_l->on_connection (callback_a); @@ -300,6 +427,9 @@ void nano::server_socket::on_connection (std::function const &, boost::system::error_code const &)> callback_a) { auto this_l (std::static_pointer_cast (shared_from_this ())); @@ -327,5 +457,13 @@ bool nano::server_socket::is_temporary_error (boost::system::error_code const ec void nano::server_socket::evict_dead_connections () { debug_assert (strand.running_in_this_thread ()); - connections.erase (std::remove_if (connections.begin (), connections.end (), [] (auto & connection) { return connection.expired (); }), connections.end ()); + for (auto it = connections_per_address.begin (); it != connections_per_address.end ();) + { + if (it->second.expired ()) + { + it = connections_per_address.erase (it); + continue; + } + ++it; + } } diff --git a/nano/node/socket.hpp b/nano/node/socket.hpp index e5670f29a6..94e42ca238 100644 --- a/nano/node/socket.hpp +++ b/nano/node/socket.hpp @@ -8,9 +8,21 @@ #include #include +#include #include #include +namespace boost +{ +namespace asio +{ + namespace ip + { + class network_v6; + } +} +} + namespace nano { /** Policy to affect at which stage a buffer can be dropped */ @@ -33,25 +45,38 @@ class socket : public std::enable_shared_from_this friend class server_socket; public: + enum class type_t + { + undefined, + bootstrap, + realtime, + realtime_response_server // special type for tcp channel response server + }; + enum class endpoint_type_t + { + server, + client + }; /** * Constructor * @param node Owning node - * @param io_timeout If tcp async operation is not completed within the timeout, the socket is closed. If not set, the tcp_io_timeout config option is used. - * @param concurrency write concurrency + * @param endpoint_type_a The endpoint's type: either server or client */ - explicit socket (nano::node & node, boost::optional io_timeout = boost::none); + explicit socket (nano::node & node, endpoint_type_t endpoint_type_a); virtual ~socket (); void async_connect (boost::asio::ip::tcp::endpoint const &, std::function); - void async_read (std::shared_ptr> const &, size_t, std::function); - void async_write (nano::shared_const_buffer const &, std::function const & = nullptr); + void async_read (std::shared_ptr> const &, std::size_t, std::function); + void async_write (nano::shared_const_buffer const &, std::function const & = nullptr); void close (); boost::asio::ip::tcp::endpoint remote_endpoint () const; + boost::asio::ip::tcp::endpoint local_endpoint () const; /** Returns true if the socket has timed out */ bool has_timed_out () const; /** This can be called to change the maximum idle time, e.g. based on the type of traffic detected. */ - void set_timeout (std::chrono::seconds io_timeout_a); + void timeout_set (std::chrono::seconds io_timeout_a); void start_timer (std::chrono::seconds deadline_a); + void set_silent_connection_tolerance_time (std::chrono::seconds tolerance_time_a); bool max () const { return queue_size >= queue_size_max; @@ -60,6 +85,26 @@ class socket : public std::enable_shared_from_this { return queue_size >= queue_size_max * 2; } + type_t type () const + { + return type_m; + }; + void type_set (type_t type_a) + { + type_m = type_a; + } + endpoint_type_t endpoint_type () const + { + return endpoint_type_m; + } + bool is_realtime_connection () + { + return type () == nano::socket::type_t::realtime || type () == nano::socket::type_t::realtime_response_server; + } + bool is_closed () + { + return closed; + } protected: /** Holds the buffer and callback for queued writes */ @@ -67,7 +112,7 @@ class socket : public std::enable_shared_from_this { public: nano::shared_const_buffer buffer; - std::function callback; + std::function callback; }; boost::asio::strand strand; @@ -78,10 +123,12 @@ class socket : public std::enable_shared_from_this boost::asio::ip::tcp::endpoint remote; std::atomic next_deadline; - std::atomic last_completion_time; + std::atomic last_completion_time_or_init; + std::atomic last_receive_time_or_init; std::atomic timed_out{ false }; - boost::optional io_timeout; - std::atomic queue_size{ 0 }; + std::atomic io_timeout; + std::chrono::seconds silent_connection_tolerance_time; + std::atomic queue_size{ 0 }; /** Set by close() - completion handlers must check this. This is more reliable than checking error codes as the OS may have already completed the async operation. */ @@ -89,12 +136,27 @@ class socket : public std::enable_shared_from_this void close_internal (); void start_timer (); void stop_timer (); + void update_last_receive_time (); void checkup (); +private: + type_t type_m{ type_t::undefined }; + endpoint_type_t endpoint_type_m; + public: - static size_t constexpr queue_size_max = 128; + static std::size_t constexpr queue_size_max = 128; }; +using address_socket_mmap = std::multimap>; + +namespace socket_functions +{ + boost::asio::ip::network_v6 get_ipv6_subnet_address (boost::asio::ip::address_v6 const &, size_t); + boost::asio::ip::address first_ipv6_subnet_address (boost::asio::ip::address_v6 const &, size_t); + boost::asio::ip::address last_ipv6_subnet_address (boost::asio::ip::address_v6 const &, size_t); + size_t count_subnetwork_connections (nano::address_socket_mmap const &, boost::asio::ip::address_v6 const &, size_t); +} + /** Socket class for TCP servers */ class server_socket final : public socket { @@ -104,9 +166,8 @@ class server_socket final : public socket * @param node_a Owning node * @param local_a Address and port to listen on * @param max_connections_a Maximum number of concurrent connections - * @param concurrency_a Write concurrency for new connections */ - explicit server_socket (nano::node & node_a, boost::asio::ip::tcp::endpoint local_a, size_t max_connections_a); + explicit server_socket (nano::node & node_a, boost::asio::ip::tcp::endpoint local_a, std::size_t max_connections_a); /**Start accepting new connections */ void start (boost::system::error_code &); /** Stop accepting new connections */ @@ -119,12 +180,29 @@ class server_socket final : public socket } private: - std::vector> connections; + nano::address_socket_mmap connections_per_address; boost::asio::ip::tcp::acceptor acceptor; boost::asio::ip::tcp::endpoint local; - size_t max_inbound_connections; + std::size_t max_inbound_connections; void evict_dead_connections (); bool is_temporary_error (boost::system::error_code const ec_a); void on_connection_requeue_delayed (std::function const & new_connection, boost::system::error_code const &)>); + /** Checks whether the maximum number of connections per IP was reached. If so, it returns true. */ + bool limit_reached_for_incoming_ip_connections (std::shared_ptr const & new_connection); + bool limit_reached_for_incoming_subnetwork_connections (std::shared_ptr const & new_connection); +}; + +/** Socket class for TCP clients */ +class client_socket final : public socket +{ +public: + /** + * Constructor + * @param node_a Owning node + */ + explicit client_socket (nano::node & node_a) : + socket{ node_a, endpoint_type_t::client } + { + } }; } diff --git a/nano/node/state_block_signature_verification.cpp b/nano/node/state_block_signature_verification.cpp index a8e61035fc..27fb471382 100644 --- a/nano/node/state_block_signature_verification.cpp +++ b/nano/node/state_block_signature_verification.cpp @@ -47,7 +47,7 @@ void nano::state_block_signature_verification::run (uint64_t state_block_signatu { if (!state_blocks.empty ()) { - size_t const max_verification_batch (state_block_signature_verification_size != 0 ? state_block_signature_verification_size : nano::signature_checker::batch_size * (node_config.signature_checker_threads + 1)); + std::size_t const max_verification_batch (state_block_signature_verification_size != 0 ? state_block_signature_verification_size : nano::signature_checker::batch_size * (node_config.signature_checker_threads + 1)); active = true; while (!state_blocks.empty () && !stopped) { @@ -83,13 +83,13 @@ void nano::state_block_signature_verification::add (nano::unchecked_info const & condition.notify_one (); } -size_t nano::state_block_signature_verification::size () +std::size_t nano::state_block_signature_verification::size () { nano::lock_guard guard (mutex); return state_blocks.size (); } -std::deque nano::state_block_signature_verification::setup_items (size_t max_count) +std::deque nano::state_block_signature_verification::setup_items (std::size_t max_count) { std::deque items; if (state_blocks.size () <= max_count) @@ -119,7 +119,7 @@ void nano::state_block_signature_verification::verify_state_blocks (std::deque messages; messages.reserve (size); - std::vector lengths; + std::vector lengths; lengths.reserve (size); std::vector accounts; accounts.reserve (size); diff --git a/nano/node/state_block_signature_verification.hpp b/nano/node/state_block_signature_verification.hpp index 05e66d801f..30a0d1e004 100644 --- a/nano/node/state_block_signature_verification.hpp +++ b/nano/node/state_block_signature_verification.hpp @@ -20,7 +20,7 @@ class state_block_signature_verification state_block_signature_verification (nano::signature_checker &, nano::epochs &, nano::node_config &, nano::logger_mt &, uint64_t); ~state_block_signature_verification (); void add (nano::unchecked_info const & info_a); - size_t size (); + std::size_t size (); void stop (); bool is_active (); @@ -41,7 +41,7 @@ class state_block_signature_verification std::thread thread; void run (uint64_t block_processor_verification_size); - std::deque setup_items (size_t); + std::deque setup_items (std::size_t); void verify_state_blocks (std::deque &); }; diff --git a/nano/node/telemetry.cpp b/nano/node/telemetry.cpp index e370e49ac3..4efb3b9e49 100644 --- a/nano/node/telemetry.cpp +++ b/nano/node/telemetry.cpp @@ -4,9 +4,9 @@ #include #include #include -#include #include #include +#include #include @@ -92,7 +92,7 @@ bool nano::telemetry::verify_message (nano::telemetry_ack const & message_a, nan if (!remove_channel) { // Check for different genesis blocks - remove_channel = (message_a.data.genesis_block != network_params.ledger.genesis_hash); + remove_channel = (message_a.data.genesis_block != network_params.ledger.genesis->hash ()); if (remove_channel) { stats.inc (nano::stat::type::telemetry, nano::stat::detail::different_genesis_hash); @@ -175,7 +175,7 @@ void nano::telemetry::ongoing_req_all_peers (std::chrono::milliseconds next_requ { // Copy peers to the multi index container so can get better asymptotic complexity in future operations - auto temp_peers = this_l->network.list (std::numeric_limits::max ()); + auto temp_peers = this_l->network.list (std::numeric_limits::max ()); peers.insert (temp_peers.begin (), temp_peers.end ()); } @@ -254,7 +254,7 @@ std::unordered_map nano::telemetry::get_me // clang-format off nano::transform_if (range.begin (), range.end (), std::inserter (telemetry_data, telemetry_data.end ()), [this](auto const & telemetry_info) { return this->within_cache_plus_buffer_cutoff (telemetry_info); }, - [](auto const & telemetry_info) { return std::pair{ telemetry_info.endpoint, telemetry_info.data }; }); + [](auto const & telemetry_info) { return std::pair{ telemetry_info.endpoint, telemetry_info.data }; }); // clang-format on return telemetry_data; @@ -352,9 +352,9 @@ void nano::telemetry::fire_request_message (std::shared_ptr this_w (shared_from_this ()); - nano::telemetry_req message; + nano::telemetry_req message{ network_params.network }; // clang-format off - channel_a->send (message, [this_w, endpoint = channel_a->get_endpoint (), round_l](boost::system::error_code const & ec, size_t size_a) { + channel_a->send (message, [this_w, endpoint = channel_a->get_endpoint (), round_l](boost::system::error_code const & ec, std::size_t size_a) { if (auto this_l = this_w.lock ()) { if (ec) @@ -447,7 +447,7 @@ void nano::telemetry::invoke_callbacks (nano::endpoint const & endpoint_a, bool } } -size_t nano::telemetry::telemetry_data_size () +std::size_t nano::telemetry::telemetry_data_size () { nano::lock_guard guard (mutex); return recent_or_initial_request_telemetry_data.size (); @@ -469,11 +469,11 @@ bool nano::telemetry_info::awaiting_first_response () const std::unique_ptr nano::collect_container_info (telemetry & telemetry, std::string const & name) { auto composite = std::make_unique (name); - size_t callbacks_count; + std::size_t callbacks_count; { nano::lock_guard guard (telemetry.mutex); std::unordered_map>> callbacks; - callbacks_count = std::accumulate (callbacks.begin (), callbacks.end (), static_cast (0), [] (auto total, auto const & callback_a) { + callbacks_count = std::accumulate (callbacks.begin (), callbacks.end (), static_cast (0), [] (auto total, auto const & callback_a) { return total += callback_a.second.size (); }); } @@ -573,7 +573,7 @@ nano::telemetry_data nano::consolidate_telemetry_data (std::vector (timestamp_sum / timestamps.size ()))); } - auto set_mode_or_average = [] (auto const & collection, auto & var, auto const & sum, size_t size) { + auto set_mode_or_average = [] (auto const & collection, auto & var, auto const & sum, std::size_t size) { auto max = std::max_element (collection.begin (), collection.end (), [] (auto const & lhs, auto const & rhs) { return lhs.second < rhs.second; }); @@ -587,7 +587,7 @@ nano::telemetry_data nano::consolidate_telemetry_data (std::vector (std::chrono::steady_clock::now () - statup_time_a).count (); - telemetry_data.unchecked_count = ledger_a.store.unchecked_count (ledger_a.store.tx_begin_read ()); - telemetry_data.genesis_block = network_params_a.ledger.genesis_hash; + telemetry_data.unchecked_count = ledger_a.store.unchecked.count (ledger_a.store.tx_begin_read ()); + telemetry_data.genesis_block = network_params_a.ledger.genesis->hash (); telemetry_data.peer_count = nano::narrow_cast (network_a.size ()); telemetry_data.account_count = ledger_a.cache.account_count; telemetry_data.major_version = nano::get_major_node_version (); diff --git a/nano/node/telemetry.hpp b/nano/node/telemetry.hpp index d965a5be57..cd902cac40 100644 --- a/nano/node/telemetry.hpp +++ b/nano/node/telemetry.hpp @@ -88,7 +88,7 @@ class telemetry : public std::enable_shared_from_this /* * Return the number of node metrics collected */ - size_t telemetry_data_size (); + std::size_t telemetry_data_size (); /* * Returns the time for the cache, response and a small buffer for alarm operations to be scheduled and completed @@ -142,7 +142,7 @@ class telemetry : public std::enable_shared_from_this bool within_cache_cutoff (nano::telemetry_info const &) const; bool within_cache_plus_buffer_cutoff (telemetry_info const &) const; bool verify_message (nano::telemetry_ack const &, nano::transport::channel const &); - friend std::unique_ptr collect_container_info (telemetry &, const std::string &); + friend std::unique_ptr collect_container_info (telemetry &, std::string const &); friend class telemetry_remove_peer_invalid_signature_Test; }; diff --git a/nano/node/transport/tcp.cpp b/nano/node/transport/tcp.cpp index 68088052a9..c0d6259a23 100644 --- a/nano/node/transport/tcp.cpp +++ b/nano/node/transport/tcp.cpp @@ -20,15 +20,10 @@ nano::transport::channel_tcp::~channel_tcp () { socket_l->close (); } - // Remove response server - if (auto response_server_l = response_server.lock ()) - { - response_server_l->stop (); - } } } -size_t nano::transport::channel_tcp::hash_code () const +std::size_t nano::transport::channel_tcp::hash_code () const { std::hash<::nano::tcp_endpoint> hash; return hash (get_tcp_endpoint ()); @@ -45,14 +40,14 @@ bool nano::transport::channel_tcp::operator== (nano::transport::channel const & return result; } -void nano::transport::channel_tcp::send_buffer (nano::shared_const_buffer const & buffer_a, std::function const & callback_a, nano::buffer_drop_policy policy_a) +void nano::transport::channel_tcp::send_buffer (nano::shared_const_buffer const & buffer_a, std::function const & callback_a, nano::buffer_drop_policy policy_a) { if (auto socket_l = socket.lock ()) { if (!socket_l->max () || (policy_a == nano::buffer_drop_policy::no_socket_drop && !socket_l->full ())) { socket_l->async_write ( - buffer_a, [endpoint_a = socket_l->remote_endpoint (), node = std::weak_ptr (node.shared ()), callback_a] (boost::system::error_code const & ec, size_t size_a) { + buffer_a, [endpoint_a = socket_l->remote_endpoint (), node = std::weak_ptr (node.shared ()), callback_a] (boost::system::error_code const & ec, std::size_t size_a) { if (auto node_l = node.lock ()) { if (!ec) @@ -110,8 +105,9 @@ void nano::transport::channel_tcp::set_endpoint () } } -nano::transport::tcp_channels::tcp_channels (nano::node & node_a) : - node (node_a) +nano::transport::tcp_channels::tcp_channels (nano::node & node, std::function const &)> sink) : + node{ node }, + sink{ sink } { } @@ -152,7 +148,7 @@ void nano::transport::tcp_channels::erase (nano::tcp_endpoint const & endpoint_a channels.get ().erase (endpoint_a); } -size_t nano::transport::tcp_channels::size () const +std::size_t nano::transport::tcp_channels::size () const { nano::lock_guard lock (mutex); return channels.size (); @@ -170,7 +166,7 @@ std::shared_ptr nano::transport::tcp_channels::fin return result; } -std::unordered_set> nano::transport::tcp_channels::random_set (size_t count_a, uint8_t min_version, bool include_temporary_channels_a) const +std::unordered_set> nano::transport::tcp_channels::random_set (std::size_t count_a, uint8_t min_version, bool include_temporary_channels_a) const { std::unordered_set> result; result.reserve (count_a); @@ -221,7 +217,7 @@ bool nano::transport::tcp_channels::store_all (bool clear_peers) nano::lock_guard lock (mutex); endpoints.reserve (channels.size ()); std::transform (channels.begin (), channels.end (), - std::back_inserter (endpoints), [] (const auto & channel) { return nano::transport::map_tcp_to_endpoint (channel.endpoint ()); }); + std::back_inserter (endpoints), [] (auto const & channel) { return nano::transport::map_tcp_to_endpoint (channel.endpoint ()); }); } bool result (false); if (!endpoints.empty ()) @@ -230,12 +226,12 @@ bool nano::transport::tcp_channels::store_all (bool clear_peers) auto transaction (node.store.tx_begin_write ({ tables::peers })); if (clear_peers) { - node.store.peer_clear (transaction); + node.store.peer.clear (transaction); } for (auto endpoint : endpoints) { nano::endpoint_key endpoint_key (endpoint.address ().to_v6 ().to_bytes (), endpoint.port ()); - node.store.peer_put (transaction, std::move (endpoint_key)); + node.store.peer.put (transaction, std::move (endpoint_key)); } result = true; } @@ -283,26 +279,27 @@ void nano::transport::tcp_channels::process_messages () auto item (node.network.tcp_message_manager.get_message ()); if (item.message != nullptr) { - process_message (*item.message, item.endpoint, item.node_id, item.socket, item.type); + process_message (*item.message, item.endpoint, item.node_id, item.socket); } } } -void nano::transport::tcp_channels::process_message (nano::message const & message_a, nano::tcp_endpoint const & endpoint_a, nano::account const & node_id_a, std::shared_ptr const & socket_a, nano::bootstrap_server_type type_a) +void nano::transport::tcp_channels::process_message (nano::message const & message_a, nano::tcp_endpoint const & endpoint_a, nano::account const & node_id_a, std::shared_ptr const & socket_a) { - if (!stopped && message_a.header.version_using >= protocol_constants ().protocol_version_min ()) + auto type_a = socket_a->type (); + if (!stopped && message_a.header.version_using >= node.network_params.network.protocol_version_min) { auto channel (node.network.find_channel (nano::transport::map_tcp_to_endpoint (endpoint_a))); if (channel) { - node.network.process_message (message_a, channel); + sink (message_a, channel); } else { channel = node.network.find_node_id (node_id_a); if (channel) { - node.network.process_message (message_a, channel); + sink (message_a, channel); } else if (!node.network.excluded_peers.check (endpoint_a)) { @@ -315,19 +312,18 @@ void nano::transport::tcp_channels::process_message (nano::message const & messa temporary_channel->set_node_id (node_id_a); temporary_channel->set_network_version (message_a.header.version_using); temporary_channel->temporary = true; - debug_assert (type_a == nano::bootstrap_server_type::realtime || type_a == nano::bootstrap_server_type::realtime_response_server); + debug_assert (type_a == nano::socket::type_t::realtime || type_a == nano::socket::type_t::realtime_response_server); // Don't insert temporary channels for response_server - if (type_a == nano::bootstrap_server_type::realtime) + if (type_a == nano::socket::type_t::realtime) { insert (temporary_channel, socket_a, nullptr); } - node.network.process_message (message_a, temporary_channel); + sink (message_a, temporary_channel); } else { // Initial node_id_handshake request without node ID debug_assert (message_a.header.type == nano::message_type::node_id_handshake); - debug_assert (type_a == nano::bootstrap_server_type::undefined); node.stats.inc (nano::stat::type::message, nano::stat::detail::node_id_handshake, nano::stat::dir::in); } } @@ -362,22 +358,21 @@ void nano::transport::tcp_channels::stop () } } channels.clear (); - node_id_handshake_sockets.clear (); } bool nano::transport::tcp_channels::max_ip_connections (nano::tcp_endpoint const & endpoint_a) { - bool result (false); - if (!node.flags.disable_max_peers_per_ip) + if (node.flags.disable_max_peers_per_ip) { - auto const address (nano::transport::ipv4_address_or_ipv6_subnet (endpoint_a.address ())); - auto const subnet (nano::transport::map_address_to_subnetwork (endpoint_a.address ())); - nano::unique_lock lock (mutex); - result = channels.get ().count (address) >= node.network_params.node.max_peers_per_ip || channels.get ().count (subnet) >= node.network_params.node.max_peers_per_subnetwork; - if (!result) - { - result = attempts.get ().count (address) >= node.network_params.node.max_peers_per_ip || attempts.get ().count (subnet) >= node.network_params.node.max_peers_per_subnetwork; - } + return false; + } + bool result{ false }; + auto const address (nano::transport::ipv4_address_or_ipv6_subnet (endpoint_a.address ())); + nano::unique_lock lock (mutex); + result = channels.get ().count (address) >= node.network_params.network.max_peers_per_ip; + if (!result) + { + result = attempts.get ().count (address) >= node.network_params.network.max_peers_per_ip; } if (result) { @@ -386,11 +381,37 @@ bool nano::transport::tcp_channels::max_ip_connections (nano::tcp_endpoint const return result; } +bool nano::transport::tcp_channels::max_subnetwork_connections (nano::tcp_endpoint const & endpoint_a) +{ + if (node.flags.disable_max_peers_per_subnetwork) + { + return false; + } + bool result{ false }; + auto const subnet (nano::transport::map_address_to_subnetwork (endpoint_a.address ())); + nano::unique_lock lock (mutex); + result = channels.get ().count (subnet) >= node.network_params.network.max_peers_per_subnetwork; + if (!result) + { + result = attempts.get ().count (subnet) >= node.network_params.network.max_peers_per_subnetwork; + } + if (result) + { + node.stats.inc (nano::stat::type::tcp, nano::stat::detail::tcp_max_per_subnetwork, nano::stat::dir::out); + } + return result; +} + +bool nano::transport::tcp_channels::max_ip_or_subnetwork_connections (nano::tcp_endpoint const & endpoint_a) +{ + return max_ip_connections (endpoint_a) || max_subnetwork_connections (endpoint_a); +} + bool nano::transport::tcp_channels::reachout (nano::endpoint const & endpoint_a) { auto tcp_endpoint (nano::transport::map_endpoint_to_tcp (endpoint_a)); // Don't overload single IP - bool error = node.network.excluded_peers.check (tcp_endpoint) || max_ip_connections (tcp_endpoint); + bool error = node.network.excluded_peers.check (tcp_endpoint) || max_ip_or_subnetwork_connections (tcp_endpoint); if (!error && !node.flags.disable_tcp_realtime) { // Don't keepalive to nodes that already sent us something @@ -404,20 +425,18 @@ bool nano::transport::tcp_channels::reachout (nano::endpoint const & endpoint_a) std::unique_ptr nano::transport::tcp_channels::collect_container_info (std::string const & name) { - size_t channels_count; - size_t attemps_count; - size_t node_id_handshake_sockets_count; + std::size_t channels_count; + std::size_t attemps_count; + std::size_t node_id_handshake_sockets_count; { nano::lock_guard guard (mutex); channels_count = channels.size (); attemps_count = attempts.size (); - node_id_handshake_sockets_count = node_id_handshake_sockets.size (); } auto composite = std::make_unique (name); composite->add_component (std::make_unique (container_info{ "channels", channels_count, sizeof (decltype (channels)::value_type) })); composite->add_component (std::make_unique (container_info{ "attempts", attemps_count, sizeof (decltype (attempts)::value_type) })); - composite->add_component (std::make_unique (container_info{ "node_id_handshake_sockets", node_id_handshake_sockets_count, sizeof (decltype (node_id_handshake_sockets)::value_type) })); return composite; } @@ -432,24 +451,18 @@ void nano::transport::tcp_channels::purge (std::chrono::steady_clock::time_point attempts.get ().erase (attempts.get ().begin (), attempts_cutoff); // Check if any tcp channels belonging to old protocol versions which may still be alive due to async operations - auto lower_bound = channels.get ().lower_bound (node.network_params.protocol.protocol_version_min ()); + auto lower_bound = channels.get ().lower_bound (node.network_params.network.protocol_version_min); channels.get ().erase (channels.get ().begin (), lower_bound); - - // Cleanup any sockets which may still be existing from failed node id handshakes - node_id_handshake_sockets.erase (std::remove_if (node_id_handshake_sockets.begin (), node_id_handshake_sockets.end (), [this] (auto socket) { - return channels.get ().find (socket->remote_endpoint ()) == channels.get ().end (); - }), - node_id_handshake_sockets.end ()); } void nano::transport::tcp_channels::ongoing_keepalive () { - nano::keepalive message; + nano::keepalive message{ node.network_params.network }; node.network.random_fill (message.peers); nano::unique_lock lock (mutex); // Wake up channels std::vector> send_list; - auto keepalive_sent_cutoff (channels.get ().lower_bound (std::chrono::steady_clock::now () - node.network_params.node.period)); + auto keepalive_sent_cutoff (channels.get ().lower_bound (std::chrono::steady_clock::now () - node.network_params.network.cleanup_period)); for (auto i (channels.get ().begin ()); i != keepalive_sent_cutoff; ++i) { send_list.push_back (i->channel); @@ -463,10 +476,10 @@ void nano::transport::tcp_channels::ongoing_keepalive () nano::tcp_endpoint invalid_endpoint (boost::asio::ip::address_v6::any (), 0); if (!node.network_params.network.is_dev_network () && !node.flags.disable_udp) { - size_t random_count (std::min (static_cast (6), static_cast (std::ceil (std::sqrt (node.network.udp_channels.size ()))))); + std::size_t random_count (std::min (static_cast (6), static_cast (std::ceil (std::sqrt (node.network.udp_channels.size ()))))); for (auto i (0); i <= random_count; ++i) { - auto tcp_endpoint (node.network.udp_channels.bootstrap_peer (node.network_params.protocol.protocol_version_min ())); + auto tcp_endpoint (node.network.udp_channels.bootstrap_peer (node.network_params.network.protocol_version_min)); if (tcp_endpoint != invalid_endpoint && find_channel (tcp_endpoint) == nullptr && !node.network.excluded_peers.check (tcp_endpoint)) { start_tcp (nano::transport::map_tcp_to_endpoint (tcp_endpoint)); @@ -474,7 +487,7 @@ void nano::transport::tcp_channels::ongoing_keepalive () } } std::weak_ptr node_w (node.shared ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.half_period, [node_w] () { + node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.network.cleanup_period_half (), [node_w] () { if (auto node_l = node_w.lock ()) { if (!node_l->network.tcp_channels.stopped) @@ -491,7 +504,7 @@ void nano::transport::tcp_channels::list_below_version (std::vector ().begin (), channels.get ().end (), std::back_inserter (channels_a), [cutoff_version_a](auto & channel_a) { return channel_a.channel->get_network_version () < cutoff_version_a; }, - [](const auto & channel) { return channel.channel; }); + [](auto const & channel) { return channel.channel; }); // clang-format on } @@ -501,7 +514,7 @@ void nano::transport::tcp_channels::list (std::deque ().begin (), channels.get ().end (), std::back_inserter (deque_a), [include_temporary_channels_a, minimum_version_a](auto & channel_a) { return channel_a.channel->get_network_version () >= minimum_version_a && (include_temporary_channels_a || !channel_a.channel->temporary); }, - [](const auto & channel) { return channel.channel; }); + [](auto const & channel) { return channel.channel; }); // clang-format on } @@ -529,113 +542,87 @@ void nano::transport::tcp_channels::update (nano::tcp_endpoint const & endpoint_ } } -bool nano::transport::tcp_channels::node_id_handhake_sockets_empty () const -{ - nano::lock_guard guard (mutex); - return node_id_handshake_sockets.empty (); -} - -void nano::transport::tcp_channels::push_node_id_handshake_socket (std::shared_ptr const & socket_a) -{ - nano::lock_guard guard (mutex); - node_id_handshake_sockets.push_back (socket_a); -} - -void nano::transport::tcp_channels::remove_node_id_handshake_socket (std::shared_ptr const & socket_a) -{ - std::weak_ptr node_w (node.shared ()); - if (auto node_l = node_w.lock ()) - { - nano::lock_guard guard (mutex); - node_id_handshake_sockets.erase (std::remove (node_id_handshake_sockets.begin (), node_id_handshake_sockets.end (), socket_a), node_id_handshake_sockets.end ()); - } -} - -void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a, std::function const &)> const & callback_a) +void nano::transport::tcp_channels::start_tcp (nano::endpoint const & endpoint_a) { if (node.flags.disable_tcp_realtime) { - node.network.tcp_channels.udp_fallback (endpoint_a, callback_a); + node.network.tcp_channels.udp_fallback (endpoint_a); return; } - auto socket = std::make_shared (node, boost::none); + auto socket = std::make_shared (node); std::weak_ptr socket_w (socket); auto channel (std::make_shared (node, socket_w)); std::weak_ptr node_w (node.shared ()); socket->async_connect (nano::transport::map_endpoint_to_tcp (endpoint_a), - [node_w, channel, socket, endpoint_a, callback_a] (boost::system::error_code const & ec) { + [node_w, channel, socket, endpoint_a] (boost::system::error_code const & ec) { if (auto node_l = node_w.lock ()) { if (!ec && channel) { // TCP node ID handshake auto cookie (node_l->network.syn_cookies.assign (endpoint_a)); - nano::node_id_handshake message (cookie, boost::none); - auto bytes = message.to_shared_const_buffer (); + nano::node_id_handshake message (node_l->network_params.network, cookie, boost::none); if (node_l->config.logging.network_node_id_handshake_logging ()) { - node_l->logger.try_log (boost::str (boost::format ("Node ID handshake request sent with node ID %1% to %2%: query %3%") % node_l->node_id.pub.to_node_id () % endpoint_a % (*cookie).to_string ())); + node_l->logger.try_log (boost::str (boost::format ("Node ID handshake request sent with node ID %1% to %2%: query %3%") % node_l->node_id.pub.to_node_id () % endpoint_a % (cookie.has_value () ? cookie->to_string () : "not set"))); } channel->set_endpoint (); std::shared_ptr> receive_buffer (std::make_shared> ()); receive_buffer->resize (256); - node_l->network.tcp_channels.push_node_id_handshake_socket (socket); - channel->send_buffer (bytes, [node_w, channel, endpoint_a, receive_buffer, callback_a] (boost::system::error_code const & ec, size_t size_a) { + channel->send (message, [node_w, channel, endpoint_a, receive_buffer] (boost::system::error_code const & ec, std::size_t size_a) { if (auto node_l = node_w.lock ()) { - if (!ec && channel) + if (!ec) { - node_l->network.tcp_channels.start_tcp_receive_node_id (channel, endpoint_a, receive_buffer, callback_a); + node_l->network.tcp_channels.start_tcp_receive_node_id (channel, endpoint_a, receive_buffer); } else { if (auto socket_l = channel->socket.lock ()) { - node_l->network.tcp_channels.remove_node_id_handshake_socket (socket_l); socket_l->close (); } if (node_l->config.logging.network_node_id_handshake_logging ()) { node_l->logger.try_log (boost::str (boost::format ("Error sending node_id_handshake to %1%: %2%") % endpoint_a % ec.message ())); } - node_l->network.tcp_channels.udp_fallback (endpoint_a, callback_a); + node_l->network.tcp_channels.udp_fallback (endpoint_a); } } }); } else { - node_l->network.tcp_channels.udp_fallback (endpoint_a, callback_a); + node_l->network.tcp_channels.udp_fallback (endpoint_a); } } }); } -void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr const & channel_a, nano::endpoint const & endpoint_a, std::shared_ptr> const & receive_buffer_a, std::function const &)> const & callback_a) +void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr const & channel_a, nano::endpoint const & endpoint_a, std::shared_ptr> const & receive_buffer_a) { std::weak_ptr node_w (node.shared ()); if (auto socket_l = channel_a->socket.lock ()) { - auto cleanup_node_id_handshake_socket = [socket_w = channel_a->socket, node_w] (nano::endpoint const & endpoint_a, std::function)> const & callback_a) { + auto cleanup_node_id_handshake_socket = [socket_w = channel_a->socket, node_w] (nano::endpoint const & endpoint_a) { if (auto node_l = node_w.lock ()) { if (auto socket_l = socket_w.lock ()) { - node_l->network.tcp_channels.remove_node_id_handshake_socket (socket_l); socket_l->close (); } } }; - auto cleanup_and_udp_fallback = [socket_w = channel_a->socket, node_w, cleanup_node_id_handshake_socket] (nano::endpoint const & endpoint_a, std::function)> const & callback_a) { + auto cleanup_and_udp_fallback = [socket_w = channel_a->socket, node_w, cleanup_node_id_handshake_socket] (nano::endpoint const & endpoint_a) { if (auto node_l = node_w.lock ()) { - node_l->network.tcp_channels.udp_fallback (endpoint_a, callback_a); - cleanup_node_id_handshake_socket (endpoint_a, callback_a); + node_l->network.tcp_channels.udp_fallback (endpoint_a); + cleanup_node_id_handshake_socket (endpoint_a); } }; - socket_l->async_read (receive_buffer_a, 8 + sizeof (nano::account) + sizeof (nano::account) + sizeof (nano::signature), [node_w, channel_a, endpoint_a, receive_buffer_a, callback_a, cleanup_and_udp_fallback, cleanup_node_id_handshake_socket] (boost::system::error_code const & ec, size_t size_a) { + socket_l->async_read (receive_buffer_a, 8 + sizeof (nano::account) + sizeof (nano::account) + sizeof (nano::signature), [node_w, channel_a, endpoint_a, receive_buffer_a, cleanup_and_udp_fallback, cleanup_node_id_handshake_socket] (boost::system::error_code const & ec, std::size_t size_a) { if (auto node_l = node_w.lock ()) { if (!ec && channel_a) @@ -646,7 +633,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr= node_l->network_params.protocol.protocol_version_min ()) + if (header.version_using >= node_l->network_params.network.protocol_version_min) { nano::node_id_handshake message (error, stream, header); if (!error && message.response && message.query) @@ -669,13 +656,12 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrset_node_id (node_id); channel_a->set_last_packet_received (std::chrono::steady_clock::now ()); boost::optional> response (std::make_pair (node_l->node_id.pub, nano::sign_message (node_l->node_id.prv, node_l->node_id.pub, *message.query))); - nano::node_id_handshake response_message (boost::none, response); - auto bytes = response_message.to_shared_const_buffer (); + nano::node_id_handshake response_message (node_l->network_params.network, boost::none, response); if (node_l->config.logging.network_node_id_handshake_logging ()) { node_l->logger.try_log (boost::str (boost::format ("Node ID handshake response sent with node ID %1% to %2%: query %3%") % node_l->node_id.pub.to_node_id () % endpoint_a % (*message.query).to_string ())); } - channel_a->send_buffer (bytes, [node_w, channel_a, endpoint_a, callback_a, cleanup_and_udp_fallback] (boost::system::error_code const & ec, size_t size_a) { + channel_a->send (response_message, [node_w, channel_a, endpoint_a, cleanup_and_udp_fallback] (boost::system::error_code const & ec, std::size_t size_a) { if (auto node_l = node_w.lock ()) { if (!ec && channel_a) @@ -686,15 +672,10 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrset_last_packet_sent (std::chrono::steady_clock::now ()); auto response_server = std::make_shared (socket_l, node_l); node_l->network.tcp_channels.insert (channel_a, socket_l, response_server); - if (callback_a) - { - callback_a (channel_a); - } // Listen for possible responses - response_server->type = nano::bootstrap_server_type::realtime_response_server; + response_server->socket->type_set (nano::socket::type_t::realtime_response_server); response_server->remote_node_id = channel_a->get_node_id (); response_server->receive (); - node_l->network.tcp_channels.remove_node_id_handshake_socket (socket_l); if (!node_l->flags.disable_initial_telemetry_requests) { @@ -710,7 +691,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrlogger.try_log (boost::str (boost::format ("Error sending node_id_handshake to %1%: %2%") % endpoint_a % ec.message ())); } - cleanup_and_udp_fallback (endpoint_a, callback_a); + cleanup_and_udp_fallback (endpoint_a); } } }); @@ -718,13 +699,13 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptr lock (node_l->network.tcp_channels.mutex); node_l->network.tcp_channels.attempts.get ().erase (nano::transport::map_endpoint_to_tcp (endpoint_a)); @@ -733,7 +714,7 @@ void nano::transport::tcp_channels::start_tcp_receive_node_id (std::shared_ptrlogger.try_log (boost::str (boost::format ("Error reading node_id_handshake from %1%: %2%") % endpoint_a % ec.message ())); } - cleanup_and_udp_fallback (endpoint_a, callback_a); + cleanup_and_udp_fallback (endpoint_a); } } }); } } -void nano::transport::tcp_channels::udp_fallback (nano::endpoint const & endpoint_a, std::function const &)> const & callback_a) +void nano::transport::tcp_channels::udp_fallback (nano::endpoint const & endpoint_a) { { nano::lock_guard lock (mutex); attempts.get ().erase (nano::transport::map_endpoint_to_tcp (endpoint_a)); } - if (callback_a && !node.flags.disable_udp) + if (!node.flags.disable_udp) { - auto channel_udp (node.network.udp_channels.create (endpoint_a)); - callback_a (channel_udp); + auto channel_udp = node.network.udp_channels.create (endpoint_a); + node.network.send_keepalive (channel_udp); } } diff --git a/nano/node/transport/tcp.hpp b/nano/node/transport/tcp.hpp index d6531ef170..353f35de37 100644 --- a/nano/node/transport/tcp.hpp +++ b/nano/node/transport/tcp.hpp @@ -17,7 +17,6 @@ namespace mi = boost::multi_index; namespace nano { class bootstrap_server; -enum class bootstrap_server_type; class tcp_message_item final { public: @@ -25,7 +24,6 @@ class tcp_message_item final nano::tcp_endpoint endpoint; nano::account node_id; std::shared_ptr socket; - nano::bootstrap_server_type type; }; namespace transport { @@ -37,16 +35,15 @@ namespace transport public: channel_tcp (nano::node &, std::weak_ptr); ~channel_tcp (); - size_t hash_code () const override; + std::size_t hash_code () const override; bool operator== (nano::transport::channel const &) const override; - void send_buffer (nano::shared_const_buffer const &, std::function const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override; + void send_buffer (nano::shared_const_buffer const &, std::function const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override; std::string to_string () const override; bool operator== (nano::transport::channel_tcp const & other_a) const { return &node == &other_a.node && socket.lock () == other_a.socket.lock (); } std::weak_ptr socket; - std::weak_ptr response_server; /* Mark for temporary channels. Usually remote ports of these channels are ephemeral and received from incoming connections to server. If remote part has open listening port, temporary channel will be replaced with direct connection to listening port soon. But if other side is behing NAT or firewall this connection can be pemanent. */ std::atomic temporary{ false }; @@ -78,13 +75,13 @@ namespace transport friend class telemetry_simultaneous_requests_Test; public: - tcp_channels (nano::node &); + tcp_channels (nano::node &, std::function const &)> = nullptr); bool insert (std::shared_ptr const &, std::shared_ptr const &, std::shared_ptr const &); void erase (nano::tcp_endpoint const &); - size_t size () const; + std::size_t size () const; std::shared_ptr find_channel (nano::tcp_endpoint const &) const; void random_fill (std::array &) const; - std::unordered_set> random_set (size_t, uint8_t = 0, bool = false) const; + std::unordered_set> random_set (std::size_t, uint8_t = 0, bool = false) const; bool store_all (bool = true); std::shared_ptr find_node_id (nano::account const &); // Get the next peer for attempting a tcp connection @@ -93,8 +90,10 @@ namespace transport void start (); void stop (); void process_messages (); - void process_message (nano::message const &, nano::tcp_endpoint const &, nano::account const &, std::shared_ptr const &, nano::bootstrap_server_type); - bool max_ip_connections (nano::tcp_endpoint const &); + void process_message (nano::message const &, nano::tcp_endpoint const &, nano::account const &, std::shared_ptr const &); + bool max_ip_connections (nano::tcp_endpoint const & endpoint_a); + bool max_subnetwork_connections (nano::tcp_endpoint const & endpoint_a); + bool max_ip_or_subnetwork_connections (nano::tcp_endpoint const & endpoint_a); // Should we reach out to this endpoint with a keepalive message bool reachout (nano::endpoint const &); std::unique_ptr collect_container_info (std::string const &); @@ -105,15 +104,13 @@ namespace transport void modify (std::shared_ptr const &, std::function const &)>); void update (nano::tcp_endpoint const &); // Connection start - void start_tcp (nano::endpoint const &, std::function const &)> const & = nullptr); - void start_tcp_receive_node_id (std::shared_ptr const &, nano::endpoint const &, std::shared_ptr> const &, std::function const &)> const &); - void udp_fallback (nano::endpoint const &, std::function const &)> const &); - void push_node_id_handshake_socket (std::shared_ptr const & socket_a); - void remove_node_id_handshake_socket (std::shared_ptr const & socket_a); - bool node_id_handhake_sockets_empty () const; + void start_tcp (nano::endpoint const &); + void start_tcp_receive_node_id (std::shared_ptr const &, nano::endpoint const &, std::shared_ptr> const &); + void udp_fallback (nano::endpoint const &); nano::node & node; private: + std::function const &)> sink; class endpoint_tag { }; @@ -230,8 +227,6 @@ namespace transport mi::member>>> attempts; // clang-format on - // This owns the sockets until the node_id_handshake has been completed. Needed to prevent self referencing callbacks, they are periodically removed if any are dangling. - std::vector> node_id_handshake_sockets; std::atomic stopped{ false }; friend class network_peer_max_tcp_attempts_subnetwork_Test; diff --git a/nano/node/transport/transport.cpp b/nano/node/transport/transport.cpp index 3f8fd72e92..d4f09b6674 100644 --- a/nano/node/transport/transport.cpp +++ b/nano/node/transport/transport.cpp @@ -2,6 +2,9 @@ #include #include +#include +#include +#include #include #include @@ -82,7 +85,7 @@ nano::tcp_endpoint nano::transport::map_endpoint_to_tcp (nano::endpoint const & boost::asio::ip::address nano::transport::map_address_to_subnetwork (boost::asio::ip::address const & address_a) { debug_assert (address_a.is_v6 ()); - static short const ipv6_subnet_prefix_length = 32; // Limits for /32 IPv6 subnetwork + static short const ipv6_subnet_prefix_length = 32; // Equivalent to network prefix /32. static short const ipv4_subnet_prefix_length = (128 - 32) + 24; // Limits for /24 IPv4 subnetwork return address_a.to_v6 ().is_v4_mapped () ? boost::asio::ip::make_network_v6 (address_a.to_v6 (), ipv4_subnet_prefix_length).network () : boost::asio::ip::make_network_v6 (address_a.to_v6 (), ipv6_subnet_prefix_length).network (); } @@ -97,10 +100,10 @@ boost::asio::ip::address nano::transport::ipv4_address_or_ipv6_subnet (boost::as nano::transport::channel::channel (nano::node & node_a) : node (node_a) { - set_network_version (node_a.network_params.protocol.protocol_version); + set_network_version (node_a.network_params.network.protocol_version); } -void nano::transport::channel::send (nano::message const & message_a, std::function const & callback_a, nano::buffer_drop_policy drop_policy_a) +void nano::transport::channel::send (nano::message & message_a, std::function const & callback_a, nano::buffer_drop_policy drop_policy_a) { callback_visitor visitor; message_a.visit (visitor); @@ -135,10 +138,10 @@ nano::transport::channel_loopback::channel_loopback (nano::node & node_a) : channel (node_a), endpoint (node_a.network.endpoint ()) { set_node_id (node_a.node_id.pub); - set_network_version (node_a.network_params.protocol.protocol_version); + set_network_version (node_a.network_params.network.protocol_version); } -size_t nano::transport::channel_loopback::hash_code () const +std::size_t nano::transport::channel_loopback::hash_code () const { std::hash<::nano::endpoint> hash; return hash (endpoint); @@ -149,7 +152,7 @@ bool nano::transport::channel_loopback::operator== (nano::transport::channel con return endpoint == other_a.get_endpoint (); } -void nano::transport::channel_loopback::send_buffer (nano::shared_const_buffer const & buffer_a, std::function const & callback_a, nano::buffer_drop_policy drop_policy_a) +void nano::transport::channel_loopback::send_buffer (nano::shared_const_buffer const & buffer_a, std::function const & callback_a, nano::buffer_drop_policy drop_policy_a) { release_assert (false && "sending to a loopback channel is not supported"); } @@ -159,12 +162,19 @@ std::string nano::transport::channel_loopback::to_string () const return boost::str (boost::format ("%1%") % endpoint); } -namespace -{ -boost::asio::ip::address_v6 mapped_from_v4_bytes (unsigned long address_a) +boost::asio::ip::address_v6 nano::transport::mapped_from_v4_bytes (unsigned long address_a) { return boost::asio::ip::address_v6::v4_mapped (boost::asio::ip::address_v4 (address_a)); } + +boost::asio::ip::address_v6 nano::transport::mapped_from_v4_or_v6 (boost::asio::ip::address const & address_a) +{ + return address_a.is_v4 () ? boost::asio::ip::address_v6::v4_mapped (address_a.to_v4 ()) : address_a.to_v6 (); +} + +bool nano::transport::is_ipv4_or_v4_mapped_address (boost::asio::ip::address const & address_a) +{ + return address_a.is_v4 () || address_a.to_v6 ().is_v4_mapped (); } bool nano::transport::reserved_address (nano::endpoint const & endpoint_a, bool allow_local_peers) @@ -268,17 +278,17 @@ bool nano::transport::reserved_address (nano::endpoint const & endpoint_a, bool using namespace std::chrono_literals; -nano::bandwidth_limiter::bandwidth_limiter (const double limit_burst_ratio_a, const size_t limit_a) : - bucket (static_cast (limit_a * limit_burst_ratio_a), limit_a) +nano::bandwidth_limiter::bandwidth_limiter (double const limit_burst_ratio_a, std::size_t const limit_a) : + bucket (static_cast (limit_a * limit_burst_ratio_a), limit_a) { } -bool nano::bandwidth_limiter::should_drop (const size_t & message_size_a) +bool nano::bandwidth_limiter::should_drop (std::size_t const & message_size_a) { return !bucket.try_consume (nano::narrow_cast (message_size_a)); } -void nano::bandwidth_limiter::reset (const double limit_burst_ratio_a, const size_t limit_a) +void nano::bandwidth_limiter::reset (double const limit_burst_ratio_a, std::size_t const limit_a) { - bucket.reset (static_cast (limit_a * limit_burst_ratio_a), limit_a); + bucket.reset (static_cast (limit_a * limit_burst_ratio_a), limit_a); } diff --git a/nano/node/transport/transport.hpp b/nano/node/transport/transport.hpp index b38672ae21..d9031ee360 100644 --- a/nano/node/transport/transport.hpp +++ b/nano/node/transport/transport.hpp @@ -14,9 +14,9 @@ class bandwidth_limiter final { public: // initialize with limit 0 = unbounded - bandwidth_limiter (const double, const size_t); - bool should_drop (const size_t &); - void reset (const double, const size_t); + bandwidth_limiter (double const, std::size_t const); + bool should_drop (std::size_t const &); + void reset (double const, std::size_t const); private: nano::rate::token_bucket bucket; @@ -30,6 +30,10 @@ namespace transport nano::tcp_endpoint map_endpoint_to_tcp (nano::endpoint const &); boost::asio::ip::address map_address_to_subnetwork (boost::asio::ip::address const &); boost::asio::ip::address ipv4_address_or_ipv6_subnet (boost::asio::ip::address const &); + boost::asio::ip::address_v6 mapped_from_v4_bytes (unsigned long); + boost::asio::ip::address_v6 mapped_from_v4_or_v6 (boost::asio::ip::address const &); + bool is_ipv4_or_v4_mapped_address (boost::asio::ip::address const &); + // Unassigned, reserved, self bool reserved_address (nano::endpoint const &, bool = false); static std::chrono::seconds constexpr syn_cookie_cutoff = std::chrono::seconds (5); @@ -45,10 +49,10 @@ namespace transport public: channel (nano::node &); virtual ~channel () = default; - virtual size_t hash_code () const = 0; + virtual std::size_t hash_code () const = 0; virtual bool operator== (nano::transport::channel const &) const = 0; - void send (nano::message const & message_a, std::function const & callback_a = nullptr, nano::buffer_drop_policy policy_a = nano::buffer_drop_policy::limiter); - virtual void send_buffer (nano::shared_const_buffer const &, std::function const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) = 0; + void send (nano::message & message_a, std::function const & callback_a = nullptr, nano::buffer_drop_policy policy_a = nano::buffer_drop_policy::limiter); + virtual void send_buffer (nano::shared_const_buffer const &, std::function const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) = 0; virtual std::string to_string () const = 0; virtual nano::endpoint get_endpoint () const = 0; virtual nano::tcp_endpoint get_tcp_endpoint () const = 0; @@ -142,9 +146,9 @@ namespace transport { public: channel_loopback (nano::node &); - size_t hash_code () const override; + std::size_t hash_code () const override; bool operator== (nano::transport::channel const &) const override; - void send_buffer (nano::shared_const_buffer const &, std::function const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override; + void send_buffer (nano::shared_const_buffer const &, std::function const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override; std::string to_string () const override; bool operator== (nano::transport::channel_loopback const & other_a) const { @@ -177,7 +181,7 @@ namespace std template <> struct hash<::nano::transport::channel> { - size_t operator() (::nano::transport::channel const & channel_a) const + std::size_t operator() (::nano::transport::channel const & channel_a) const { return channel_a.hash_code (); } @@ -197,7 +201,7 @@ namespace boost template <> struct hash<::nano::transport::channel> { - size_t operator() (::nano::transport::channel const & channel_a) const + std::size_t operator() (::nano::transport::channel const & channel_a) const { std::hash<::nano::transport::channel> hash; return hash (channel_a); @@ -206,7 +210,7 @@ struct hash<::nano::transport::channel> template <> struct hash> { - size_t operator() (std::reference_wrapper<::nano::transport::channel const> const & channel_a) const + std::size_t operator() (std::reference_wrapper<::nano::transport::channel const> const & channel_a) const { std::hash<::nano::transport::channel> hash; return hash (channel_a.get ()); diff --git a/nano/node/transport/udp.cpp b/nano/node/transport/udp.cpp index 0c06ecc119..8013e1a81c 100644 --- a/nano/node/transport/udp.cpp +++ b/nano/node/transport/udp.cpp @@ -16,7 +16,7 @@ nano::transport::channel_udp::channel_udp (nano::transport::udp_channels & chann debug_assert (endpoint_a.address ().is_v6 ()); } -size_t nano::transport::channel_udp::hash_code () const +std::size_t nano::transport::channel_udp::hash_code () const { std::hash<::nano::endpoint> hash; return hash (endpoint); @@ -33,10 +33,10 @@ bool nano::transport::channel_udp::operator== (nano::transport::channel const & return result; } -void nano::transport::channel_udp::send_buffer (nano::shared_const_buffer const & buffer_a, std::function const & callback_a, nano::buffer_drop_policy drop_policy_a) +void nano::transport::channel_udp::send_buffer (nano::shared_const_buffer const & buffer_a, std::function const & callback_a, nano::buffer_drop_policy drop_policy_a) { set_last_packet_sent (std::chrono::steady_clock::now ()); - channels.send (buffer_a, endpoint, [node = std::weak_ptr (channels.node.shared ()), callback_a] (boost::system::error_code const & ec, size_t size_a) { + channels.send (buffer_a, endpoint, [node = std::weak_ptr (channels.node.shared ()), callback_a] (boost::system::error_code const & ec, std::size_t size_a) { if (auto node_l = node.lock ()) { if (ec == boost::system::errc::host_unreachable) @@ -61,9 +61,10 @@ std::string nano::transport::channel_udp::to_string () const return boost::str (boost::format ("%1%") % endpoint); } -nano::transport::udp_channels::udp_channels (nano::node & node_a, uint16_t port_a) : - node (node_a), - strand (node_a.io_ctx.get_executor ()) +nano::transport::udp_channels::udp_channels (nano::node & node_a, uint16_t port_a, std::function const &)> sink) : + node{ node_a }, + strand{ node_a.io_ctx.get_executor () }, + sink{ sink } { if (!node.flags.disable_udp) { @@ -83,7 +84,7 @@ nano::transport::udp_channels::udp_channels (nano::node & node_a, uint16_t port_ } } -void nano::transport::udp_channels::send (nano::shared_const_buffer const & buffer_a, nano::endpoint endpoint_a, std::function const & callback_a) +void nano::transport::udp_channels::send (nano::shared_const_buffer const & buffer_a, nano::endpoint endpoint_a, std::function const & callback_a) { boost::asio::post (strand, [this, buffer_a, endpoint_a, callback_a] () { @@ -99,7 +100,7 @@ std::shared_ptr nano::transport::udp_channels::ins { debug_assert (endpoint_a.address ().is_v6 ()); std::shared_ptr result; - if (!node.network.not_a_peer (endpoint_a, node.config.allow_local_peers) && (node.network_params.network.is_dev_network () || !max_ip_connections (endpoint_a))) + if (!node.network.not_a_peer (endpoint_a, node.config.allow_local_peers) && (node.network_params.network.is_dev_network () || !max_ip_or_subnetwork_connections (endpoint_a))) { nano::unique_lock lock (mutex); auto existing (channels.get ().find (endpoint_a)); @@ -125,7 +126,7 @@ void nano::transport::udp_channels::erase (nano::endpoint const & endpoint_a) channels.get ().erase (endpoint_a); } -size_t nano::transport::udp_channels::size () const +std::size_t nano::transport::udp_channels::size () const { nano::lock_guard lock (mutex); return channels.size (); @@ -143,7 +144,7 @@ std::shared_ptr nano::transport::udp_channels::cha return result; } -std::unordered_set> nano::transport::udp_channels::random_set (size_t count_a, uint8_t min_version) const +std::unordered_set> nano::transport::udp_channels::random_set (std::size_t count_a, uint8_t min_version) const { std::unordered_set> result; result.reserve (count_a); @@ -193,7 +194,7 @@ bool nano::transport::udp_channels::store_all (bool clear_peers) nano::lock_guard lock (mutex); endpoints.reserve (channels.size ()); std::transform (channels.begin (), channels.end (), - std::back_inserter (endpoints), [] (const auto & channel) { return channel.endpoint (); }); + std::back_inserter (endpoints), [] (auto const & channel) { return channel.endpoint (); }); } bool result (false); if (!endpoints.empty ()) @@ -202,12 +203,12 @@ bool nano::transport::udp_channels::store_all (bool clear_peers) auto transaction (node.store.tx_begin_write ({ tables::peers })); if (clear_peers) { - node.store.peer_clear (transaction); + node.store.peer.clear (transaction); } for (auto endpoint : endpoints) { nano::endpoint_key endpoint_key (endpoint.address ().to_v6 ().to_bytes (), endpoint.port ()); - node.store.peer_put (transaction, std::move (endpoint_key)); + node.store.peer.put (transaction, std::move (endpoint_key)); } result = true; } @@ -312,7 +313,7 @@ void nano::transport::udp_channels::receive () void nano::transport::udp_channels::start () { debug_assert (!node.flags.disable_udp); - for (size_t i = 0; i < node.config.io_threads && !stopped; ++i) + for (std::size_t i = 0; i < node.config.io_threads && !stopped; ++i) { boost::asio::post (strand, [this] () { receive (); @@ -364,14 +365,15 @@ namespace class udp_message_visitor : public nano::message_visitor { public: - udp_message_visitor (nano::node & node_a, nano::endpoint const & endpoint_a) : - node (node_a), - endpoint (endpoint_a) + udp_message_visitor (nano::node & node_a, nano::endpoint const & endpoint_a, std::function const &)> sink) : + node{ node_a }, + endpoint{ endpoint_a }, + sink{ sink } { } void keepalive (nano::keepalive const & message_a) override { - if (!node.network.udp_channels.max_ip_connections (endpoint)) + if (!node.network.udp_channels.max_ip_or_subnetwork_connections (endpoint)) { auto cookie (node.network.syn_cookies.assign (endpoint)); if (cookie) @@ -386,7 +388,7 @@ class udp_message_visitor : public nano::message_visitor else if (!node.network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (endpoint))) { // Don't start connection if TCP channel to same IP:port exists - find_channel = std::make_shared (node.network.udp_channels, endpoint, node.network_params.protocol.protocol_version); + find_channel = std::make_shared (node.network.udp_channels, endpoint, node.network_params.network.protocol_version); node.network.send_node_id_handshake (find_channel, *cookie, boost::none); } } @@ -498,7 +500,7 @@ class udp_message_visitor : public nano::message_visitor auto find_channel (node.network.udp_channels.channel (endpoint)); if (!find_channel) { - find_channel = std::make_shared (node.network.udp_channels, endpoint, node.network_params.protocol.protocol_version); + find_channel = std::make_shared (node.network.udp_channels, endpoint, node.network_params.network.protocol_version); } node.network.send_node_id_handshake (find_channel, out_query, out_respond_to); } @@ -512,11 +514,12 @@ class udp_message_visitor : public nano::message_visitor node.network.udp_channels.modify (find_channel, [] (std::shared_ptr const & channel_a) { channel_a->set_last_packet_received (std::chrono::steady_clock::now ()); }); - node.network.process_message (message_a, find_channel); + sink (message_a, find_channel); } } nano::node & node; nano::endpoint endpoint; + std::function const &)> sink; }; } @@ -537,8 +540,8 @@ void nano::transport::udp_channels::receive_action (nano::message_buffer * data_ } if (allowed_sender) { - udp_message_visitor visitor (node, data_a->endpoint); - nano::message_parser parser (node.network.publish_filter, node.block_uniquer, node.vote_uniquer, visitor, node.work); + udp_message_visitor visitor (node, data_a->endpoint, sink); + nano::message_parser parser (node.network.publish_filter, node.block_uniquer, node.vote_uniquer, visitor, node.work, node.network_params.network); parser.deserialize_buffer (data_a->buffer, data_a->size); if (parser.status == nano::message_parser::parse_status::success) { @@ -622,26 +625,50 @@ void nano::transport::udp_channels::process_packets () std::shared_ptr nano::transport::udp_channels::create (nano::endpoint const & endpoint_a) { - return std::make_shared (*this, endpoint_a, node.network_params.protocol.protocol_version); + return std::make_shared (*this, endpoint_a, node.network_params.network.protocol_version); } bool nano::transport::udp_channels::max_ip_connections (nano::endpoint const & endpoint_a) { - bool result (false); - if (!node.flags.disable_max_peers_per_ip) + if (node.flags.disable_max_peers_per_ip) { - auto const address (nano::transport::ipv4_address_or_ipv6_subnet (endpoint_a.address ())); - auto const subnet (nano::transport::map_address_to_subnetwork (endpoint_a.address ())); - nano::unique_lock lock (mutex); - result = channels.get ().count (address) >= node.network_params.node.max_peers_per_ip || channels.get ().count (subnet) >= node.network_params.node.max_peers_per_subnetwork; + return false; + } + auto const address (nano::transport::ipv4_address_or_ipv6_subnet (endpoint_a.address ())); + nano::unique_lock lock (mutex); + auto const result = channels.get ().count (address) >= node.network_params.network.max_peers_per_ip; + if (!result) + { + node.stats.inc (nano::stat::type::udp, nano::stat::detail::udp_max_per_ip, nano::stat::dir::out); } return result; } +bool nano::transport::udp_channels::max_subnetwork_connections (nano::endpoint const & endpoint_a) +{ + if (node.flags.disable_max_peers_per_subnetwork) + { + return false; + } + auto const subnet (nano::transport::map_address_to_subnetwork (endpoint_a.address ())); + nano::unique_lock lock (mutex); + auto const result = channels.get ().count (subnet) >= node.network_params.network.max_peers_per_subnetwork; + if (!result) + { + node.stats.inc (nano::stat::type::udp, nano::stat::detail::udp_max_per_subnetwork, nano::stat::dir::out); + } + return result; +} + +bool nano::transport::udp_channels::max_ip_or_subnetwork_connections (nano::endpoint const & endpoint_a) +{ + return max_ip_connections (endpoint_a) || max_subnetwork_connections (endpoint_a); +} + bool nano::transport::udp_channels::reachout (nano::endpoint const & endpoint_a) { // Don't overload single IP - bool error = max_ip_connections (endpoint_a); + bool error = max_ip_or_subnetwork_connections (endpoint_a); if (!error && !node.flags.disable_udp) { auto endpoint_l (nano::transport::map_endpoint_to_v6 (endpoint_a)); @@ -656,8 +683,8 @@ bool nano::transport::udp_channels::reachout (nano::endpoint const & endpoint_a) std::unique_ptr nano::transport::udp_channels::collect_container_info (std::string const & name) { - size_t channels_count; - size_t attemps_count; + std::size_t channels_count; + std::size_t attemps_count; { nano::lock_guard guard (mutex); channels_count = channels.size (); @@ -683,11 +710,11 @@ void nano::transport::udp_channels::purge (std::chrono::steady_clock::time_point void nano::transport::udp_channels::ongoing_keepalive () { - nano::keepalive message; + nano::keepalive message{ node.network_params.network }; node.network.random_fill (message.peers); std::vector> send_list; nano::unique_lock lock (mutex); - auto keepalive_cutoff (channels.get ().lower_bound (std::chrono::steady_clock::now () - node.network_params.node.period)); + auto keepalive_cutoff (channels.get ().lower_bound (std::chrono::steady_clock::now () - node.network_params.network.cleanup_period)); for (auto i (channels.get ().begin ()); i != keepalive_cutoff; ++i) { send_list.push_back (i->channel); @@ -698,7 +725,7 @@ void nano::transport::udp_channels::ongoing_keepalive () channel->send (message); } std::weak_ptr node_w (node.shared ()); - node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.node.period, [node_w] () { + node.workers.add_timed_task (std::chrono::steady_clock::now () + node.network_params.network.cleanup_period, [node_w] () { if (auto node_l = node_w.lock ()) { node_l->network.udp_channels.ongoing_keepalive (); @@ -712,7 +739,7 @@ void nano::transport::udp_channels::list_below_version (std::vector ().begin (), channels.get ().end (), std::back_inserter (channels_a), [cutoff_version_a](auto & channel_a) { return channel_a.channel->get_network_version () < cutoff_version_a; }, - [](const auto & channel) { return channel.channel; }); + [](auto const & channel) { return channel.channel; }); // clang-format on } @@ -722,7 +749,7 @@ void nano::transport::udp_channels::list (std::deque ().begin (), channels.get ().end (), std::back_inserter (deque_a), [minimum_version_a](auto & channel_a) { return channel_a.channel->get_network_version () >= minimum_version_a; }, - [](const auto & channel) { return channel.channel; }); + [](auto const & channel) { return channel.channel; }); // clang-format on } diff --git a/nano/node/transport/udp.hpp b/nano/node/transport/udp.hpp index 4806976771..25e88e56d1 100644 --- a/nano/node/transport/udp.hpp +++ b/nano/node/transport/udp.hpp @@ -27,9 +27,9 @@ namespace transport public: channel_udp (nano::transport::udp_channels &, nano::endpoint const &, uint8_t protocol_version); - size_t hash_code () const override; + std::size_t hash_code () const override; bool operator== (nano::transport::channel const &) const override; - void send_buffer (nano::shared_const_buffer const &, std::function const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override; + void send_buffer (nano::shared_const_buffer const &, std::function const & = nullptr, nano::buffer_drop_policy = nano::buffer_drop_policy::limiter) override; std::string to_string () const override; bool operator== (nano::transport::channel_udp const & other_a) const { @@ -75,13 +75,13 @@ namespace transport friend class nano::transport::channel_udp; public: - udp_channels (nano::node &, uint16_t); + udp_channels (nano::node &, uint16_t, std::function const &)> sink); std::shared_ptr insert (nano::endpoint const &, unsigned); void erase (nano::endpoint const &); - size_t size () const; + std::size_t size () const; std::shared_ptr channel (nano::endpoint const &) const; void random_fill (std::array &) const; - std::unordered_set> random_set (size_t, uint8_t = 0) const; + std::unordered_set> random_set (std::size_t, uint8_t = 0) const; bool store_all (bool = true); std::shared_ptr find_node_id (nano::account const &); void clean_node_id (nano::account const &); @@ -91,12 +91,14 @@ namespace transport void receive (); void start (); void stop (); - void send (nano::shared_const_buffer const & buffer_a, nano::endpoint endpoint_a, std::function const & callback_a); + void send (nano::shared_const_buffer const & buffer_a, nano::endpoint endpoint_a, std::function const & callback_a); nano::endpoint get_local_endpoint () const; void receive_action (nano::message_buffer *); void process_packets (); std::shared_ptr create (nano::endpoint const &); - bool max_ip_connections (nano::endpoint const &); + bool max_ip_connections (nano::endpoint const & endpoint_a); + bool max_subnetwork_connections (nano::endpoint const & endpoint_a); + bool max_ip_or_subnetwork_connections (nano::endpoint const & endpoint_a); // Should we reach out to this endpoint with a keepalive message bool reachout (nano::endpoint const &); std::unique_ptr collect_container_info (std::string const &); @@ -106,6 +108,7 @@ namespace transport void list (std::deque> &, uint8_t = 0); void modify (std::shared_ptr const &, std::function const &)>); nano::node & node; + std::function const &)> sink; private: void close_socket (); diff --git a/nano/node/vote_processor.cpp b/nano/node/vote_processor.cpp index 954419dd93..a85025643f 100644 --- a/nano/node/vote_processor.cpp +++ b/nano/node/vote_processor.cpp @@ -9,9 +9,9 @@ #include #include #include -#include #include #include +#include #include @@ -140,7 +140,7 @@ void nano::vote_processor::verify_votes (decltype (votes) const & votes_a) messages.reserve (size); std::vector hashes; hashes.reserve (size); - std::vector lengths (size, sizeof (nano::block_hash)); + std::vector lengths (size, sizeof (nano::block_hash)); std::vector pub_keys; pub_keys.reserve (size); std::vector signatures; @@ -198,7 +198,7 @@ nano::vote_code nano::vote_processor::vote_blocking (std::shared_ptr } if (config.logging.vote_logging ()) { - logger.try_log (boost::str (boost::format ("Vote from: %1% timestamp: %2% block(s): %3%status: %4%") % vote_a->account.to_account () % std::to_string (vote_a->timestamp) % vote_a->hashes_string () % status)); + logger.try_log (boost::str (boost::format ("Vote from: %1% timestamp: %2% duration %3%ms block(s): %4% status: %5%") % vote_a->account.to_account () % std::to_string (vote_a->timestamp ()) % std::to_string (vote_a->duration ().count ()) % vote_a->hashes_string () % status)); } return result; } @@ -234,7 +234,7 @@ void nano::vote_processor::flush_active () } } -size_t nano::vote_processor::size () +std::size_t nano::vote_processor::size () { nano::lock_guard guard (mutex); return votes.size (); @@ -283,10 +283,10 @@ void nano::vote_processor::calculate_weights () std::unique_ptr nano::collect_container_info (vote_processor & vote_processor, std::string const & name) { - size_t votes_count; - size_t representatives_1_count; - size_t representatives_2_count; - size_t representatives_3_count; + std::size_t votes_count; + std::size_t representatives_1_count; + std::size_t representatives_2_count; + std::size_t representatives_3_count; { nano::lock_guard guard (vote_processor.mutex); diff --git a/nano/node/vote_processor.hpp b/nano/node/vote_processor.hpp index 9dab5323e1..d1175363f9 100644 --- a/nano/node/vote_processor.hpp +++ b/nano/node/vote_processor.hpp @@ -14,7 +14,7 @@ namespace nano { class signature_checker; class active_transactions; -class block_store; +class store; class node_observers; class stats; class node_config; @@ -24,6 +24,7 @@ class rep_crawler; class ledger; class network_params; class node_flags; +class stat; class transaction; namespace transport @@ -43,7 +44,7 @@ class vote_processor final void flush (); /** Block until the currently active processing cycle finishes */ void flush_active (); - size_t size (); + std::size_t size (); bool empty (); bool half_full (); void calculate_weights (); @@ -63,7 +64,7 @@ class vote_processor final nano::rep_crawler & rep_crawler; nano::ledger & ledger; nano::network_params & network_params; - size_t max_votes; + std::size_t max_votes; std::deque, std::shared_ptr>> votes; /** Representatives levels for random early detection */ std::unordered_set representatives_1; diff --git a/nano/node/voting.cpp b/nano/node/voting.cpp index 520e02d0c4..124879d52c 100644 --- a/nano/node/voting.cpp +++ b/nano/node/voting.cpp @@ -6,8 +6,8 @@ #include #include #include -#include #include +#include #include @@ -44,7 +44,7 @@ void nano::vote_spacing::flag (nano::root const & root_a, nano::block_hash const } } -size_t nano::vote_spacing::size () const +std::size_t nano::vote_spacing::size () const { return recent.size (); } @@ -75,11 +75,11 @@ void nano::local_vote_history::add (nano::root const & root_a, nano::block_hash auto range (history_by_root.equal_range (root_a)); for (auto i (range.first); i != range.second;) { - if (i->hash != hash_a || (vote_a->account == i->vote->account && i->vote->timestamp <= vote_a->timestamp)) + if (i->hash != hash_a || (vote_a->account == i->vote->account && i->vote->timestamp () <= vote_a->timestamp ())) { i = history_by_root.erase (i); } - else if (vote_a->account == i->vote->account && i->vote->timestamp > vote_a->timestamp) + else if (vote_a->account == i->vote->account && i->vote->timestamp () > vote_a->timestamp ()) { add_vote = false; ++i; @@ -123,7 +123,7 @@ std::vector> nano::local_vote_history::votes (nano:: auto range (history.get ().equal_range (root_a)); // clang-format off nano::transform_if (range.first, range.second, std::back_inserter (result), - [&hash_a, is_final_a](auto const & entry) { return entry.hash == hash_a && (!is_final_a || entry.vote->timestamp == std::numeric_limits::max ()); }, + [&hash_a, is_final_a](auto const & entry) { return entry.hash == hash_a && (!is_final_a || entry.vote->timestamp () == std::numeric_limits::max ()); }, [](auto const & entry) { return entry.vote; }); // clang-format on return result; @@ -145,7 +145,7 @@ void nano::local_vote_history::clean () } } -size_t nano::local_vote_history::size () const +std::size_t nano::local_vote_history::size () const { nano::lock_guard guard (mutex); return history.size (); @@ -153,7 +153,7 @@ size_t nano::local_vote_history::size () const std::unique_ptr nano::collect_container_info (nano::local_vote_history & history, std::string const & name) { - size_t history_count = history.size (); + std::size_t history_count = history.size (); auto sizeof_element = sizeof (decltype (history.history)::value_type); auto composite = std::make_unique (name); /* This does not currently loop over each element inside the cache to get the sizes of the votes inside history*/ @@ -193,14 +193,14 @@ void nano::vote_generator::add (nano::root const & root_a, nano::block_hash cons if (is_final) { auto transaction (ledger.store.tx_begin_write ({ tables::final_votes })); - auto block (ledger.store.block_get (transaction, hash_a)); - should_vote = block != nullptr && ledger.dependents_confirmed (transaction, *block) && ledger.store.final_vote_put (transaction, block->qualified_root (), hash_a); + auto block (ledger.store.block.get (transaction, hash_a)); + should_vote = block != nullptr && ledger.dependents_confirmed (transaction, *block) && ledger.store.final_vote.put (transaction, block->qualified_root (), hash_a); debug_assert (block == nullptr || root_a == block->root ()); } else { auto transaction (ledger.store.tx_begin_read ()); - auto block (ledger.store.block_get (transaction, hash_a)); + auto block (ledger.store.block.get (transaction, hash_a)); should_vote = block != nullptr && ledger.dependents_confirmed (transaction, *block); } if (should_vote) @@ -230,7 +230,7 @@ void nano::vote_generator::stop () } } -size_t nano::vote_generator::generate (std::vector> const & blocks_a, std::shared_ptr const & channel_a) +std::size_t nano::vote_generator::generate (std::vector> const & blocks_a, std::shared_ptr const & channel_a) { request_t::first_type req_candidates; { @@ -361,12 +361,13 @@ void nano::vote_generator::vote (std::vector const & hashes_a, debug_assert (hashes_a.size () == roots_a.size ()); std::vector> votes_l; wallets.foreach_representative ([this, &hashes_a, &votes_l] (nano::public_key const & pub_a, nano::raw_key const & prv_a) { - auto timestamp (this->is_final ? std::numeric_limits::max () : nano::milliseconds_since_epoch ()); - votes_l.emplace_back (std::make_shared (pub_a, prv_a, timestamp, hashes_a)); + auto timestamp = this->is_final ? nano::vote::timestamp_max : nano::milliseconds_since_epoch (); + uint8_t duration = this->is_final ? nano::vote::duration_max : /*8192ms*/ 0x9; + votes_l.emplace_back (std::make_shared (pub_a, prv_a, timestamp, duration, hashes_a)); }); for (auto const & vote_l : votes_l) { - for (size_t i (0), n (hashes_a.size ()); i != n; ++i) + for (std::size_t i (0), n (hashes_a.size ()); i != n; ++i) { history.add (roots_a[i], hashes_a[i], vote_l); spacing.flag (roots_a[i], hashes_a[i]); @@ -439,8 +440,8 @@ void nano::vote_generator_session::flush () std::unique_ptr nano::collect_container_info (nano::vote_generator & vote_generator, std::string const & name) { - size_t candidates_count = 0; - size_t requests_count = 0; + std::size_t candidates_count = 0; + std::size_t requests_count = 0; { nano::lock_guard guard (vote_generator.mutex); candidates_count = vote_generator.candidates.size (); diff --git a/nano/node/voting.hpp b/nano/node/voting.hpp index ed53cd3f2a..c404a02425 100644 --- a/nano/node/voting.hpp +++ b/nano/node/voting.hpp @@ -59,7 +59,7 @@ class vote_spacing final } bool votable (nano::root const & root_a, nano::block_hash const & hash_a) const; void flag (nano::root const & root_a, nano::block_hash const & hash_a); - size_t size () const; + std::size_t size () const; }; class local_vote_history final @@ -88,7 +88,7 @@ class local_vote_history final std::vector> votes (nano::root const & root_a, nano::block_hash const & hash_a, bool const is_final_a = false) const; bool exists (nano::root const &) const; - size_t size () const; + std::size_t size () const; private: // clang-format off @@ -124,7 +124,7 @@ class vote_generator final /** Queue items for vote generation, or broadcast votes already in cache */ void add (nano::root const &, nano::block_hash const &); /** Queue blocks for vote generation, returning the number of successful candidates.*/ - size_t generate (std::vector> const & blocks_a, std::shared_ptr const & channel_a); + std::size_t generate (std::vector> const & blocks_a, std::shared_ptr const & channel_a); void set_reply_action (std::function const &, std::shared_ptr const &)>); void stop (); @@ -145,10 +145,9 @@ class vote_generator final nano::stat & stats; mutable nano::mutex mutex; nano::condition_variable condition; - static size_t constexpr max_requests{ 2048 }; + static std::size_t constexpr max_requests{ 2048 }; std::deque requests; std::deque candidates; - nano::network_params network_params; std::atomic stopped{ false }; bool started{ false }; std::thread thread; diff --git a/nano/node/wallet.cpp b/nano/node/wallet.cpp index 7a676654f6..59f669d8f4 100644 --- a/nano/node/wallet.cpp +++ b/nano/node/wallet.cpp @@ -199,7 +199,7 @@ void nano::wallet_store::derive_key (nano::raw_key & prv_a, nano::transaction co kdf.phs (prv_a, password_a, salt_l); } -nano::fan::fan (nano::raw_key const & key, size_t count_a) +nano::fan::fan (nano::raw_key const & key, std::size_t count_a) { auto first (std::make_unique (key)); for (auto i (1); i < count_a; ++i) @@ -238,7 +238,7 @@ void nano::fan::value_set (nano::raw_key const & value_a) } // Wallet version number -nano::account const nano::wallet_store::version_special (0); +nano::account const nano::wallet_store::version_special{}; // Random number used to salt private key encryption nano::account const nano::wallet_store::salt_special (1); // Key used to encrypt wallet keys, encrypted itself by the user password @@ -252,8 +252,8 @@ nano::account const nano::wallet_store::seed_special (5); // Current key index for deterministic keys nano::account const nano::wallet_store::deterministic_index_special (6); int const nano::wallet_store::special_count (7); -size_t const nano::wallet_store::check_iv_index (0); -size_t const nano::wallet_store::seed_iv_index (1); +std::size_t const nano::wallet_store::check_iv_index (0); +std::size_t const nano::wallet_store::seed_iv_index (1); nano::wallet_store::wallet_store (bool & init_a, nano::kdf & kdf_a, nano::transaction & transaction_a, nano::account representative_a, unsigned fanout_a, std::string const & wallet_a, std::string const & json_a) : password (0, fanout_a), @@ -651,9 +651,8 @@ void nano::wallet_store::version_put (nano::transaction const & transaction_a, u void nano::kdf::phs (nano::raw_key & result_a, std::string const & password_a, nano::uint256_union const & salt_a) { - static nano::network_params network_params; nano::lock_guard lock (mutex); - auto success (argon2_hash (1, network_params.kdf_work, 1, password_a.data (), password_a.size (), salt_a.bytes.data (), salt_a.bytes.size (), result_a.bytes.data (), result_a.bytes.size (), NULL, 0, Argon2_d, 0x10)); + auto success (argon2_hash (1, kdf_work, 1, password_a.data (), password_a.size (), salt_a.bytes.data (), salt_a.bytes.size (), result_a.bytes.data (), result_a.bytes.size (), NULL, 0, Argon2_d, 0x10)); debug_assert (success == 0); (void)success; } @@ -715,7 +714,7 @@ bool nano::wallet::enter_password (nano::transaction const & transaction_a, std: nano::public_key nano::wallet::deterministic_insert (nano::transaction const & transaction_a, bool generate_work_a) { - nano::public_key key (0); + nano::public_key key{}; if (store.valid_password (transaction_a)) { key = store.deterministic_insert (transaction_a); @@ -736,7 +735,7 @@ nano::public_key nano::wallet::deterministic_insert (nano::transaction const & t nano::public_key nano::wallet::deterministic_insert (uint32_t const index, bool generate_work_a) { auto transaction (wallets.tx_begin_write ()); - nano::public_key key (0); + nano::public_key key{}; if (store.valid_password (transaction)) { key = store.deterministic_insert (transaction, index); @@ -757,7 +756,7 @@ nano::public_key nano::wallet::deterministic_insert (bool generate_work_a) nano::public_key nano::wallet::insert_adhoc (nano::raw_key const & key_a, bool generate_work_a) { - nano::public_key key (0); + nano::public_key key{}; auto transaction (wallets.tx_begin_write ()); if (store.valid_password (transaction)) { @@ -841,7 +840,7 @@ std::shared_ptr nano::wallet::receive_action (nano::block_hash cons nano::pending_info pending_info; if (wallets.node.ledger.block_or_pruned_exists (block_transaction, send_hash_a)) { - if (!wallets.node.ledger.store.pending_get (block_transaction, nano::pending_key (account_a, send_hash_a), pending_info)) + if (!wallets.node.ledger.store.pending.get (block_transaction, nano::pending_key (account_a, send_hash_a), pending_info)) { nano::raw_key prv; if (!store.fetch (transaction, account_a, prv)) @@ -851,7 +850,7 @@ std::shared_ptr nano::wallet::receive_action (nano::block_hash cons store.work_get (transaction, account_a, work_a); } nano::account_info info; - auto new_account (wallets.node.ledger.store.account_get (block_transaction, account_a, info)); + auto new_account (wallets.node.ledger.store.account.get (block_transaction, account_a, info)); if (!new_account) { block = std::make_shared (account_a, info.head, info.representative, info.balance.number () + pending_info.amount.number (), send_hash_a, prv, account_a, work_a); @@ -907,7 +906,7 @@ std::shared_ptr nano::wallet::change_action (nano::account const & if (existing != store.end () && !wallets.node.ledger.latest (block_transaction, source_a).is_zero ()) { nano::account_info info; - auto error1 (wallets.node.ledger.store.account_get (block_transaction, source_a, info)); + auto error1 (wallets.node.ledger.store.account.get (block_transaction, source_a, info)); (void)error1; debug_assert (!error1); nano::raw_key prv; @@ -942,7 +941,7 @@ std::shared_ptr nano::wallet::send_action (nano::account const & so id_mdb_val = nano::mdb_val (id_a->size (), const_cast (id_a->data ())); } - auto prepare_send = [&id_mdb_val, &wallets = this->wallets, &store = this->store, &source_a, &amount_a, &work_a, &account_a] (const auto & transaction) { + auto prepare_send = [&id_mdb_val, &wallets = this->wallets, &store = this->store, &source_a, &amount_a, &work_a, &account_a] (auto const & transaction) { auto block_transaction (wallets.node.store.tx_begin_read ()); auto error (false); auto cached_block (false); @@ -956,7 +955,7 @@ std::shared_ptr nano::wallet::send_action (nano::account const & so if (status == 0) { nano::block_hash hash (result); - block = wallets.node.store.block_get (block_transaction, hash); + block = wallets.node.store.block.get (block_transaction, hash); if (block != nullptr) { cached_block = true; @@ -979,7 +978,7 @@ std::shared_ptr nano::wallet::send_action (nano::account const & so if (!balance.is_zero () && balance >= amount_a) { nano::account_info info; - auto error1 (wallets.node.ledger.store.account_get (block_transaction, source_a, info)); + auto error1 (wallets.node.ledger.store.account.get (block_transaction, source_a, info)); (void)error1; debug_assert (!error1); nano::raw_key prv; @@ -1044,8 +1043,8 @@ bool nano::wallet::action_complete (std::shared_ptr const & block_a wallets.delayed_work->erase (account_a); if (block_a != nullptr) { - auto required_difficulty{ nano::work_threshold (block_a->work_version (), details_a) }; - if (block_a->difficulty () < required_difficulty) + auto required_difficulty{ wallets.node.network_params.work.threshold (block_a->work_version (), details_a) }; + if (wallets.node.network_params.work.difficulty (*block_a) < required_difficulty) { wallets.node.logger.try_log (boost::str (boost::format ("Cached or provided work for block %1% account %2% is invalid, regenerating") % block_a->hash ().to_string () % account_a.to_account ())); debug_assert (required_difficulty <= wallets.node.max_work_generate_difficulty (block_a->work_version ())); @@ -1131,7 +1130,7 @@ void nano::wallet::send_async (nano::account const & source_a, nano::account con // Update work for account if latest root is root_a void nano::wallet::work_update (nano::transaction const & transaction_a, nano::account const & account_a, nano::root const & root_a, uint64_t work_a) { - debug_assert (!nano::work_validate_entry (nano::work_version::work_1, root_a, work_a)); + debug_assert (!wallets.node.network_params.work.validate_entry (nano::work_version::work_1, root_a, work_a)); debug_assert (store.exists (transaction_a, account_a)); auto block_transaction (wallets.node.store.tx_begin_read ()); auto latest (wallets.node.ledger.latest_root (block_transaction, account_a)); @@ -1170,7 +1169,7 @@ bool nano::wallet::search_pending (nano::transaction const & wallet_transaction_ auto result (!store.valid_password (wallet_transaction_a)); if (!result) { - wallets.node.logger.try_log ("Beginning pending block search"); + wallets.node.logger.try_log ("Beginning receivable block search"); for (auto i (store.begin (wallet_transaction_a)), n (store.end ()); i != n; ++i) { auto block_transaction (wallets.node.store.tx_begin_read ()); @@ -1178,7 +1177,7 @@ bool nano::wallet::search_pending (nano::transaction const & wallet_transaction_ // Don't search pending for watch-only accounts if (!nano::wallet_value (i->second).key.is_zero ()) { - for (auto j (wallets.node.store.pending_begin (block_transaction, nano::pending_key (account, 0))), k (wallets.node.store.pending_end ()); j != k && nano::pending_key (j->first).account == account; ++j) + for (auto j (wallets.node.store.pending.begin (block_transaction, nano::pending_key (account, 0))), k (wallets.node.store.pending.end ()); j != k && nano::pending_key (j->first).account == account; ++j) { nano::pending_key key (j->first); auto hash (key.hash); @@ -1186,7 +1185,7 @@ bool nano::wallet::search_pending (nano::transaction const & wallet_transaction_ auto amount (pending.amount.number ()); if (wallets.node.config.receive_minimum.number () <= amount) { - wallets.node.logger.try_log (boost::str (boost::format ("Found a pending block %1% for account %2%") % hash.to_string () % pending.source.to_account ())); + wallets.node.logger.try_log (boost::str (boost::format ("Found a receivable block %1% for account %2%") % hash.to_string () % pending.source.to_account ())); if (wallets.node.ledger.block_confirmed (block_transaction, hash)) { auto representative = store.representative (wallet_transaction_a); @@ -1195,7 +1194,7 @@ bool nano::wallet::search_pending (nano::transaction const & wallet_transaction_ } else if (!wallets.node.confirmation_height_processor.is_processing_block (hash)) { - auto block (wallets.node.store.block_get (block_transaction, hash)); + auto block (wallets.node.store.block.get (block_transaction, hash)); if (block) { // Request confirmation for block which is not being processed yet @@ -1206,7 +1205,7 @@ bool nano::wallet::search_pending (nano::transaction const & wallet_transaction_ } } } - wallets.node.logger.try_log ("Pending block search phase complete"); + wallets.node.logger.try_log ("Receivable block search phase completed"); } else { @@ -1243,7 +1242,7 @@ uint32_t nano::wallet::deterministic_check (nano::transaction const & transactio else { // Check if there are pending blocks for account - for (auto ii (wallets.node.store.pending_begin (block_transaction, nano::pending_key (pair.pub, 0))), nn (wallets.node.store.pending_end ()); ii != nn && nano::pending_key (ii->first).account == pair.pub; ++ii) + for (auto ii (wallets.node.store.pending.begin (block_transaction, nano::pending_key (pair.pub, 0))), nn (wallets.node.store.pending.end ()); ii != nn && nano::pending_key (ii->first).account == pair.pub; ++ii) { index = i; n = i + 64 + (i / 64); @@ -1335,14 +1334,12 @@ void nano::wallets::do_wallet_actions () } nano::wallets::wallets (bool error_a, nano::node & node_a) : + network_params{ node_a.config.network_params }, observer ([] (bool) {}), + kdf{ node_a.config.network_params.kdf_work }, node (node_a), env (boost::polymorphic_downcast (node_a.wallets_store_impl.get ())->environment), - stopped (false), - thread ([this] () { - nano::thread_role::set (nano::thread_role::name::wallet_actions); - do_wallet_actions (); - }) + stopped (false) { nano::unique_lock lock (mutex); if (!error_a) @@ -1390,9 +1387,9 @@ nano::wallets::wallets (bool error_a, nano::node & node_a) : } if (backup_required) { - const char * store_path; + char const * store_path; mdb_env_get_path (env, &store_path); - const boost::filesystem::path path (store_path); + boost::filesystem::path const path (store_path); nano::mdb_store::create_backup_file (env, path, node_a.logger); } for (auto & item : items) @@ -1605,6 +1602,14 @@ void nano::wallets::stop () } } +void nano::wallets::start () +{ + thread = std::thread{ [this] () { + nano::thread_role::set (nano::thread_role::name::wallet_actions); + do_wallet_actions (); + } }; +} + nano::write_transaction nano::wallets::tx_begin_write () { return env.tx_begin_write (); @@ -1628,26 +1633,35 @@ nano::wallet_representatives nano::wallets::reps () const return representatives; } -bool nano::wallets::check_rep (nano::account const & account_a, nano::uint128_t const & half_principal_weight_a, const bool acquire_lock_a) +bool nano::wallets::check_rep (nano::account const & account_a, nano::uint128_t const & half_principal_weight_a, bool const acquire_lock_a) { - bool result (false); - auto weight (node.ledger.weight (account_a)); - if (weight >= node.config.vote_minimum.number ()) + auto weight = node.ledger.weight (account_a); + + if (weight < node.config.vote_minimum.number ()) { - nano::unique_lock lock; - if (acquire_lock_a) - { - lock = nano::unique_lock (reps_cache_mutex); - } - result = true; - representatives.accounts.insert (account_a); - ++representatives.voting; - if (weight >= half_principal_weight_a) - { - ++representatives.half_principal; - } + return false; // account not a representative } - return result; + + nano::unique_lock lock; + if (acquire_lock_a) + { + lock = nano::unique_lock (reps_cache_mutex); + } + + if (weight >= half_principal_weight_a) + { + representatives.half_principal = true; + } + + auto insert_result = representatives.accounts.insert (account_a); + if (!insert_result.second) + { + return false; // account already exists + } + + ++representatives.voting; + + return true; } void nano::wallets::compute_reps () @@ -1684,7 +1698,7 @@ void nano::wallets::ongoing_compute_reps () }); } -void nano::wallets::split_if_needed (nano::transaction & transaction_destination, nano::block_store & store_a) +void nano::wallets::split_if_needed (nano::transaction & transaction_destination, nano::store & store_a) { auto store_l (dynamic_cast (&store_a)); if (store_l != nullptr) @@ -1822,8 +1836,8 @@ MDB_txn * nano::wallet_store::tx (nano::transaction const & transaction_a) const std::unique_ptr nano::collect_container_info (wallets & wallets, std::string const & name) { - size_t items_count; - size_t actions_count; + std::size_t items_count; + std::size_t actions_count; { nano::lock_guard guard (wallets.mutex); items_count = wallets.items.size (); diff --git a/nano/node/wallet.hpp b/nano/node/wallet.hpp index c52f5f600d..0731bc0e4a 100644 --- a/nano/node/wallet.hpp +++ b/nano/node/wallet.hpp @@ -6,8 +6,8 @@ #include #include #include -#include #include +#include #include #include @@ -22,7 +22,7 @@ class wallets; class fan final { public: - fan (nano::raw_key const &, size_t); + fan (nano::raw_key const &, std::size_t); void value (nano::raw_key &); void value_set (nano::raw_key const &); std::vector> values; @@ -34,8 +34,13 @@ class fan final class kdf final { public: + kdf (unsigned & kdf_work) : + kdf_work{ kdf_work } + { + } void phs (nano::raw_key &, std::string const &, nano::uint256_union const &); nano::mutex mutex; + unsigned & kdf_work; }; enum class key_type { @@ -105,8 +110,8 @@ class wallet_store final static nano::account const representative_special; static nano::account const seed_special; static nano::account const deterministic_index_special; - static size_t const check_iv_index; - static size_t const seed_iv_index; + static std::size_t const check_iv_index; + static std::size_t const seed_iv_index; static int const special_count; nano::kdf & kdf; std::atomic handle{ 0 }; @@ -152,7 +157,6 @@ class wallet final : public std::enable_shared_from_this nano::public_key change_seed (nano::transaction const & transaction_a, nano::raw_key const & prv_a, uint32_t count = 0); void deterministic_restore (nano::transaction const & transaction_a); bool live (); - nano::network_params network_params; std::unordered_set free_accounts; std::function lock_observer; nano::wallet_store store; @@ -165,11 +169,11 @@ class wallet_representatives { public: uint64_t voting{ 0 }; // Number of representatives with at least the configured minimum voting weight - uint64_t half_principal{ 0 }; // Number of representatives with at least 50% of principal representative requirements + bool half_principal{ false }; // has representatives with at least 50% of principal representative requirements std::unordered_set accounts; // Representatives with at least the configured minimum voting weight bool have_half_rep () const { - return half_principal > 0; + return half_principal; } bool exists (nano::account const & rep_a) const { @@ -178,7 +182,7 @@ class wallet_representatives void clear () { voting = 0; - half_principal = 0; + half_principal = false; accounts.clear (); } }; @@ -202,16 +206,17 @@ class wallets final void queue_wallet_action (nano::uint128_t const &, std::shared_ptr const &, std::function); void foreach_representative (std::function const &); bool exists (nano::transaction const &, nano::account const &); + void start (); void stop (); void clear_send_ids (nano::transaction const &); nano::wallet_representatives reps () const; - bool check_rep (nano::account const &, nano::uint128_t const &, const bool = true); + bool check_rep (nano::account const &, nano::uint128_t const &, bool const = true); void compute_reps (); void ongoing_compute_reps (); - void split_if_needed (nano::transaction &, nano::block_store &); + void split_if_needed (nano::transaction &, nano::store &); void move_table (std::string const &, MDB_txn *, MDB_txn *); std::unordered_map> get_wallets (); - nano::network_params network_params; + nano::network_params & network_params; std::function observer; std::unordered_map> items; std::multimap, std::function>, std::greater> actions; diff --git a/nano/node/websocket.cpp b/nano/node/websocket.cpp index 84d701b6d7..8793da3821 100644 --- a/nano/node/websocket.cpp +++ b/nano/node/websocket.cpp @@ -1,6 +1,8 @@ #include #include #include +#include +#include #include #include #include @@ -68,7 +70,7 @@ nano::websocket::confirmation_options::confirmation_options (boost::property_tre has_account_filtering_options = true; for (auto account_l : *accounts_l) { - nano::account result_l (0); + nano::account result_l{}; if (!result_l.decode_account (account_l.second.data ())) { // Do not insert the given raw data to keep old prefix support @@ -114,7 +116,8 @@ bool nano::websocket::confirmation_options::should_filter (nano::websocket::mess if (all_local_accounts) { auto transaction_l (wallets.tx_begin_read ()); - nano::account source_l (0), destination_l (0); + nano::account source_l{}; + nano::account destination_l{}; auto decode_source_ok_l (!source_l.decode_account (source_text_l)); auto decode_destination_ok_l (!destination_l.decode_account (destination_opt_l.get ())); (void)decode_source_ok_l; @@ -140,7 +143,7 @@ bool nano::websocket::confirmation_options::update (boost::property_tree::ptree this->has_account_filtering_options = true; for (auto const & account_l : accounts_text_a) { - nano::account result_l (0); + nano::account result_l{}; if (!result_l.decode_account (account_l.second.data ())) { // Re-encode to keep old prefix support @@ -197,7 +200,7 @@ nano::websocket::vote_options::vote_options (boost::property_tree::ptree const & { for (auto representative_l : *representatives_l) { - nano::account result_l (0); + nano::account result_l{}; if (!result_l.decode_account (representative_l.second.data ())) { // Do not insert the given raw data to keep old prefix support @@ -231,10 +234,19 @@ bool nano::websocket::vote_options::should_filter (nano::websocket::message cons return should_filter_l; } +#ifdef NANO_SECURE_RPC + +nano::websocket::session::session (nano::websocket::listener & listener_a, socket_type socket_a, boost::asio::ssl::context & ctx_a) : + ws_listener (listener_a), ws (std::move (socket_a), ctx_a) +{ + ws_listener.get_logger ().try_log ("Websocket: secure session started"); +} + +#endif + nano::websocket::session::session (nano::websocket::listener & listener_a, socket_type socket_a) : - ws_listener (listener_a), ws (std::move (socket_a)), strand (ws.get_executor ()) + ws_listener (listener_a), ws (std::move (socket_a)) { - ws.text (true); ws_listener.get_logger ().try_log ("Websocket: session started"); } @@ -252,7 +264,7 @@ nano::websocket::session::~session () void nano::websocket::session::handshake () { auto this_l (shared_from_this ()); - ws.async_accept ([this_l] (boost::system::error_code const & ec) { + ws.handshake ([this_l] (boost::system::error_code const & ec) { if (!ec) { // Start reading incoming messages @@ -270,7 +282,7 @@ void nano::websocket::session::close () ws_listener.get_logger ().try_log ("Websocket: session closing"); auto this_l (shared_from_this ()); - boost::asio::dispatch (strand, + boost::asio::dispatch (ws.get_strand (), [this_l] () { boost::beast::websocket::close_reason reason; reason.code = boost::beast::websocket::close_code::normal; @@ -288,7 +300,7 @@ void nano::websocket::session::write (nano::websocket::message message_a) { lk.unlock (); auto this_l (shared_from_this ()); - boost::asio::post (strand, + boost::asio::post (ws.get_strand (), [message_a, this_l] () { bool write_in_progress = !this_l->send_queue.empty (); this_l->send_queue.emplace_back (message_a); @@ -306,7 +318,6 @@ void nano::websocket::session::write_queued_messages () auto this_l (shared_from_this ()); ws.async_write (nano::shared_const_buffer (msg), - boost::asio::bind_executor (strand, [this_l] (boost::system::error_code ec, std::size_t bytes_transferred) { this_l->send_queue.pop_front (); if (!ec) @@ -316,16 +327,15 @@ void nano::websocket::session::write_queued_messages () this_l->write_queued_messages (); } } - })); + }); } void nano::websocket::session::read () { auto this_l (shared_from_this ()); - boost::asio::post (strand, [this_l] () { + boost::asio::post (ws.get_strand (), [this_l] () { this_l->ws.async_read (this_l->read_buffer, - boost::asio::bind_executor (this_l->strand, [this_l] (boost::system::error_code ec, std::size_t bytes_transferred) { if (!ec) { @@ -352,7 +362,7 @@ void nano::websocket::session::read () { this_l->ws_listener.get_logger ().try_log ("Websocket: read failed: ", ec.message ()); } - })); + }); }); } @@ -540,7 +550,8 @@ void nano::websocket::listener::stop () sessions.clear (); } -nano::websocket::listener::listener (nano::logger_mt & logger_a, nano::wallets & wallets_a, boost::asio::io_context & io_ctx_a, boost::asio::ip::tcp::endpoint endpoint_a) : +nano::websocket::listener::listener (std::shared_ptr const & tls_config_a, nano::logger_mt & logger_a, nano::wallets & wallets_a, boost::asio::io_context & io_ctx_a, boost::asio::ip::tcp::endpoint endpoint_a) : + tls_config (tls_config_a), logger (logger_a), wallets (wallets_a), acceptor (io_ctx_a), @@ -589,7 +600,18 @@ void nano::websocket::listener::on_accept (boost::system::error_code ec) else { // Create the session and initiate websocket handshake - auto session (std::make_shared (*this, std::move (socket))); + std::shared_ptr session; + if (tls_config && tls_config->enable_wss) + { +#ifdef NANO_SECURE_RPC + session = std::make_shared (*this, std::move (socket), tls_config->ssl_context); +#endif + } + else + { + session = std::make_shared (*this, std::move (socket)); + } + sessions_mutex.lock (); sessions.push_back (session); // Clean up expired sessions @@ -692,6 +714,7 @@ nano::websocket::message nano::websocket::message_builder::block_confirmed (std: boost::property_tree::ptree message_node_l; message_node_l.add ("account", account_a.to_account ()); message_node_l.add ("amount", amount_a.to_string_dec ()); + message_node_l.add ("amount_decimal", convert_raw_to_dec (amount_a.to_string_dec ())); message_node_l.add ("hash", block_a->hash ().to_string ()); std::string confirmation_type = "unknown"; @@ -717,6 +740,7 @@ nano::websocket::message nano::websocket::message_builder::block_confirmed (std: election_node_l.add ("duration", election_status_a.election_duration.count ()); election_node_l.add ("time", election_status_a.election_end.count ()); election_node_l.add ("tally", election_status_a.tally.to_string_dec ()); + election_node_l.add ("tally_decimal", convert_raw_to_dec (election_status_a.tally.to_string_dec ())); election_node_l.add ("final", election_status_a.final_tally.to_string_dec ()); election_node_l.add ("blocks", std::to_string (election_status_a.block_count)); election_node_l.add ("voters", std::to_string (election_status_a.voter_count)); @@ -731,6 +755,7 @@ nano::websocket::message nano::websocket::message_builder::block_confirmed (std: entry.put ("timestamp", vote_l.timestamp); entry.put ("hash", vote_l.hash.to_string ()); entry.put ("weight", vote_l.weight.convert_to ()); + entry.put ("weight", convert_raw_to_dec (vote_l.weight.convert_to ())); election_votes_l.push_back (std::make_pair ("", entry)); } election_node_l.add_child ("votes", election_votes_l); @@ -793,7 +818,8 @@ nano::websocket::message nano::websocket::message_builder::work_generation (nano // Active difficulty information boost::property_tree::ptree work_l; work_l.put ("success", completed_a ? "true" : "false"); - work_l.put ("reason", completed_a ? "" : cancelled_a ? "cancelled" : "failure"); + work_l.put ("reason", completed_a ? "" : cancelled_a ? "cancelled" + : "failure"); work_l.put ("duration", duration_a.count ()); boost::property_tree::ptree request_l; @@ -809,7 +835,7 @@ nano::websocket::message nano::websocket::message_builder::work_generation (nano boost::property_tree::ptree result_l; result_l.put ("source", peer_a); result_l.put ("work", nano::to_string_hex (work_a)); - auto result_difficulty_l (nano::work_difficulty (version_a, root_a, work_a)); + auto result_difficulty_l (nano::dev::network_params.work.difficulty (version_a, root_a, work_a)); result_l.put ("difficulty", nano::to_string_hex (result_difficulty_l)); auto result_multiplier_l (nano::difficulty::to_multiplier (result_difficulty_l, publish_threshold_a)); result_l.put ("multiplier", nano::to_string (result_multiplier_l)); diff --git a/nano/node/websocket.hpp b/nano/node/websocket.hpp index 1da806ee7b..74d0e3ba45 100644 --- a/nano/node/websocket.hpp +++ b/nano/node/websocket.hpp @@ -1,13 +1,11 @@ #pragma once -#include -#include -#include #include #include #include #include #include +#include #include #include @@ -20,15 +18,6 @@ #include #include -/* Boost v1.70 introduced breaking changes; the conditional compilation allows 1.6x to be supported as well. */ -#if BOOST_VERSION < 107000 -using socket_type = boost::asio::ip::tcp::socket; -#define beast_buffers boost::beast::buffers -#else -using socket_type = boost::asio::basic_stream_socket; -#define beast_buffers boost::beast::make_printable -#endif - namespace nano { class wallets; @@ -36,6 +25,7 @@ class logger_mt; class vote; class election_status; class telemetry_data; +class tls_config; enum class election_status_type : uint8_t; namespace websocket { @@ -66,7 +56,7 @@ namespace websocket /** Auxiliary length, not a valid topic, must be the last enum */ _length }; - constexpr size_t number_topics{ static_cast (topic::_length) - static_cast (topic::invalid) }; + constexpr std::size_t number_topics{ static_cast (topic::_length) - static_cast (topic::invalid) }; /** A message queued for broadcasting */ class message final @@ -184,11 +174,11 @@ namespace websocket return include_election_info_with_votes; } - static constexpr const uint8_t type_active_quorum = 1; - static constexpr const uint8_t type_active_confirmation_height = 2; - static constexpr const uint8_t type_inactive = 4; - static constexpr const uint8_t type_all_active = type_active_quorum | type_active_confirmation_height; - static constexpr const uint8_t type_all = type_all_active | type_inactive; + static constexpr uint8_t const type_active_quorum = 1; + static constexpr uint8_t const type_active_confirmation_height = 2; + static constexpr uint8_t const type_inactive = 4; + static constexpr uint8_t const type_all_active = type_active_quorum | type_active_confirmation_height; + static constexpr uint8_t const type_all = type_all_active | type_inactive; private: void check_filter_empty () const; @@ -233,8 +223,13 @@ namespace websocket friend class listener; public: +#ifdef NANO_SECURE_RPC + /** Constructor that takes ownership over \p socket_a and creates an SSL stream */ + explicit session (nano::websocket::listener & listener_a, socket_type socket_a, boost::asio::ssl::context & ctx_a); +#endif /** Constructor that takes ownership over \p socket_a */ explicit session (nano::websocket::listener & listener_a, socket_type socket_a); + ~session (); /** Perform Websocket handshake and start reading messages */ @@ -252,12 +247,10 @@ namespace websocket private: /** The owning listener */ nano::websocket::listener & ws_listener; - /** Websocket */ - boost::beast::websocket::stream ws; + /** Websocket stream, supporting both plain and tls connections */ + nano::websocket::stream ws; /** Buffer for received messages */ boost::beast::multi_buffer read_buffer; - /** All websocket operations that are thread unsafe must go through a strand. */ - boost::asio::strand strand; /** Outgoing messages. The send queue is protected by accessing it only through the strand */ std::deque send_queue; @@ -286,7 +279,7 @@ namespace websocket class listener final : public std::enable_shared_from_this { public: - listener (nano::logger_mt & logger_a, nano::wallets & wallets_a, boost::asio::io_context & io_ctx_a, boost::asio::ip::tcp::endpoint endpoint_a); + listener (std::shared_ptr const & tls_config_a, nano::logger_mt & logger_a, nano::wallets & wallets_a, boost::asio::io_context & io_ctx_a, boost::asio::ip::tcp::endpoint endpoint_a); /** Start accepting connections */ void run (); @@ -321,7 +314,7 @@ namespace websocket return subscriber_count (topic_a) > 0; } /** Getter for subscriber count of a specific topic*/ - size_t subscriber_count (nano::websocket::topic const & topic_a) const + std::size_t subscriber_count (nano::websocket::topic const & topic_a) const { return topic_subscriber_count[static_cast (topic_a)]; } @@ -335,6 +328,7 @@ namespace websocket /** Removes from subscription count of a specific topic*/ void decrease_subscriber_count (nano::websocket::topic const & topic_a); + std::shared_ptr tls_config; nano::logger_mt & logger; nano::wallets & wallets; boost::asio::ip::tcp::acceptor acceptor; diff --git a/nano/node/websocket_stream.cpp b/nano/node/websocket_stream.cpp new file mode 100644 index 0000000000..74d5eaf8a3 --- /dev/null +++ b/nano/node/websocket_stream.cpp @@ -0,0 +1,126 @@ +#include + +#include + +namespace +{ +/** Type-erasing wrapper for tls and non-tls websocket streams */ +template +class stream_wrapper : public nano::websocket::websocket_stream_concept +{ +public: +#ifdef NANO_SECURE_RPC + stream_wrapper (socket_type socket_a, boost::asio::ssl::context & ctx_a) : + ws (std::move (socket_a), ctx_a), strand (ws.get_executor ()) + { + is_tls = true; + ws.text (true); + } +#endif + + stream_wrapper (socket_type socket_a) : + ws (std::move (socket_a)), strand (ws.get_executor ()) + { + ws.text (true); + } + + void handshake (std::function callback_a) override + { + if (is_tls) + { + ssl_handshake (callback_a); + } + else + { + // Websocket handshake + ws.async_accept ([callback_a] (boost::system::error_code const & ec) { + callback_a (ec); + }); + } + } + + void ssl_handshake (std::function callback_a) + { +#ifdef NANO_SECURE_RPC + // Only perform TLS handshakes for TLS streams + if constexpr (std::is_same::value) + { + ws.next_layer ().async_handshake (boost::asio::ssl::stream_base::server, [this, callback_a] (boost::system::error_code const & ec) { + if (!ec) + { + // Websocket handshake + this->ws.async_accept ([callback_a] (boost::system::error_code const & ec) { + callback_a (ec); + }); + } + else + { + callback_a (ec); + } + }); + } +#endif + } + + boost::asio::strand & get_strand () override + { + return strand; + } + + void close (boost::beast::websocket::close_reason const & reason_a, boost::system::error_code & ec_a) override + { + ws.close (reason_a, ec_a); + } + + void async_write (nano::shared_const_buffer const & buffer_a, std::function callback_a) override + { + ws.async_write (buffer_a, boost::asio::bind_executor (strand, callback_a)); + } + + void async_read (boost::beast::multi_buffer & buffer_a, std::function callback_a) override + { + ws.async_read (buffer_a, boost::asio::bind_executor (strand, callback_a)); + } + +private: + bool is_tls{ false }; + stream_type ws; + boost::asio::strand strand; +}; +} + +#ifdef NANO_SECURE_RPC +nano::websocket::stream::stream (socket_type socket_a, boost::asio::ssl::context & ctx_a) +{ + impl = std::make_unique> (std::move (socket_a), ctx_a); +} +#endif +nano::websocket::stream::stream (socket_type socket_a) +{ + impl = std::make_unique> (std::move (socket_a)); +} + +[[nodiscard]] boost::asio::strand & nano::websocket::stream::get_strand () +{ + return impl->get_strand (); +} + +void nano::websocket::stream::handshake (std::function callback_a) +{ + impl->handshake (callback_a); +} + +void nano::websocket::stream::close (boost::beast::websocket::close_reason const & reason_a, boost::system::error_code & ec_a) +{ + impl->close (reason_a, ec_a); +} + +void nano::websocket::stream::async_write (nano::shared_const_buffer const & buffer_a, std::function callback_a) +{ + impl->async_write (buffer_a, callback_a); +} + +void nano::websocket::stream::async_read (boost::beast::multi_buffer & buffer_a, std::function callback_a) +{ + impl->async_read (buffer_a, callback_a); +} diff --git a/nano/node/websocket_stream.hpp b/nano/node/websocket_stream.hpp new file mode 100644 index 0000000000..03e21490ce --- /dev/null +++ b/nano/node/websocket_stream.hpp @@ -0,0 +1,62 @@ +#pragma once + +#include +#include +#include +#include + +#include + +/* Boost v1.70 introduced breaking changes; the conditional compilation allows 1.6x to be supported as well. */ +#if BOOST_VERSION < 107000 +using socket_type = boost::asio::ip::tcp::socket; +#define beast_buffers boost::beast::buffers +#else +using socket_type = boost::asio::basic_stream_socket; +#define beast_buffers boost::beast::make_printable +#endif +using ws_type = boost::beast::websocket::stream; + +#ifdef NANO_SECURE_RPC +#include +#include +#include +using wss_type = boost::beast::websocket::stream>; +#endif + +namespace nano::websocket +{ +/** The minimal stream interface needed by the Nano websocket implementation */ +class websocket_stream_concept +{ +public: + virtual ~websocket_stream_concept () = default; + virtual boost::asio::strand & get_strand () = 0; + virtual void handshake (std::function callback_a) = 0; + virtual void close (boost::beast::websocket::close_reason const & reason_a, boost::system::error_code & ec_a) = 0; + virtual void async_write (nano::shared_const_buffer const & buffer_a, std::function callback_a) = 0; + virtual void async_read (boost::beast::multi_buffer & buffer_a, std::function callback_a) = 0; +}; + +/** + * Beast websockets doesn't provide a common base type for tls and non-tls streams, so we use + * the type erasure idiom to be able to use both kinds of streams through a common type. + */ +class stream final : public websocket_stream_concept +{ +public: +#ifdef NANO_SECURE_RPC + stream (socket_type socket_a, boost::asio::ssl::context & ctx_a); +#endif + stream (socket_type socket_a); + + [[nodiscard]] boost::asio::strand & get_strand () override; + void handshake (std::function callback_a) override; + void close (boost::beast::websocket::close_reason const & reason_a, boost::system::error_code & ec_a) override; + void async_write (nano::shared_const_buffer const & buffer_a, std::function callback_a) override; + void async_read (boost::beast::multi_buffer & buffer_a, std::function callback_a) override; + +private: + std::unique_ptr impl; +}; +} diff --git a/nano/node/websocketconfig.cpp b/nano/node/websocketconfig.cpp index 7d49986d11..a6d9484f15 100644 --- a/nano/node/websocketconfig.cpp +++ b/nano/node/websocketconfig.cpp @@ -3,9 +3,10 @@ #include #include -nano::websocket::config::config () : - port (network_constants.default_websocket_port), - address (boost::asio::ip::address_v6::loopback ().to_string ()) +nano::websocket::config::config (nano::network_constants & network_constants) : + network_constants{ network_constants }, + port{ network_constants.default_websocket_port }, + address{ boost::asio::ip::address_v6::loopback ().to_string () } { } diff --git a/nano/node/websocketconfig.hpp b/nano/node/websocketconfig.hpp index f8b9eeef7b..9c9bbbfac9 100644 --- a/nano/node/websocketconfig.hpp +++ b/nano/node/websocketconfig.hpp @@ -3,25 +3,30 @@ #include #include +#include + namespace nano { class jsonconfig; class tomlconfig; +class tls_config; namespace websocket { /** websocket configuration */ class config final { public: - config (); + config (nano::network_constants & network_constants); nano::error deserialize_json (nano::jsonconfig & json_a); nano::error serialize_json (nano::jsonconfig & json) const; nano::error deserialize_toml (nano::tomlconfig & toml_a); nano::error serialize_toml (nano::tomlconfig & toml) const; - nano::network_constants network_constants; + nano::network_constants & network_constants; bool enabled{ false }; uint16_t port; std::string address; + /** Optional TLS config */ + std::shared_ptr tls_config; }; } } diff --git a/nano/node/write_database_queue.cpp b/nano/node/write_database_queue.cpp index cf2d30f77a..8bb42fe322 100644 --- a/nano/node/write_database_queue.cpp +++ b/nano/node/write_database_queue.cpp @@ -90,7 +90,7 @@ nano::write_guard nano::write_database_queue::wait (nano::writer writer) bool nano::write_database_queue::contains (nano::writer writer) { - debug_assert (!use_noops && nano::network_constants ().is_dev_network ()); + debug_assert (!use_noops); nano::lock_guard guard (mutex); return std::find (queue.cbegin (), queue.cend (), writer) != queue.cend (); } diff --git a/nano/qt/qt.cpp b/nano/qt/qt.cpp index bef177ffb1..16fb0e9d86 100644 --- a/nano/qt/qt.cpp +++ b/nano/qt/qt.cpp @@ -115,7 +115,7 @@ void nano_qt::self_pane::set_balance_text (std::pairsetText (QString (final_text.c_str ())); } @@ -272,7 +272,7 @@ void nano_qt::accounts::refresh_wallet_balance () auto final_text (std::string ("Balance: ") + wallet.format_balance (balance)); if (!pending.is_zero ()) { - final_text += "\nPending: " + wallet.format_balance (pending); + final_text += "\nReady to receive: " + wallet.format_balance (pending); } wallet_balance_label->setText (QString (final_text.c_str ())); this->wallet.node.workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::seconds (60), [this] () { @@ -542,9 +542,8 @@ class short_text_visitor : public nano::block_visitor } void open_block (nano::open_block const & block_a) { - static nano::network_params params; type = "Receive"; - if (block_a.hashables.source != params.ledger.genesis_account) + if (block_a.hashables.source != ledger.constants.genesis->account ()) { bool error_or_pruned (false); account = ledger.account_safe (transaction, block_a.hashables.source, error_or_pruned); @@ -556,8 +555,8 @@ class short_text_visitor : public nano::block_visitor } else { - account = params.ledger.genesis_account; - amount = params.ledger.genesis_amount; + account = ledger.constants.genesis->account (); + amount = nano::dev::constants.genesis_amount; } } void change_block (nano::change_block const & block_a) @@ -624,7 +623,7 @@ void nano_qt::history::refresh () for (auto i (0), n (tx_count->value ()); i < n && !hash.is_zero (); ++i) { QList items; - auto block (ledger.store.block_get (transaction, hash)); + auto block (ledger.store.block.get (transaction, hash)); if (block != nullptr) { block->visit (visitor); @@ -673,13 +672,13 @@ nano_qt::block_viewer::block_viewer (nano_qt::wallet & wallet_a) : if (!hash_l.decode_hex (hash->text ().toStdString ())) { auto transaction (this->wallet.node.store.tx_begin_read ()); - auto block_l (this->wallet.node.store.block_get (transaction, hash_l)); + auto block_l (this->wallet.node.store.block.get (transaction, hash_l)); if (block_l != nullptr) { std::string contents; block_l->serialize_json (contents); block->setPlainText (contents.c_str ()); - auto successor_l (this->wallet.node.store.block_successor (transaction, hash_l)); + auto successor_l (this->wallet.node.store.block.successor (transaction, hash_l)); successor->setText (successor_l.to_string ().c_str ()); } else @@ -698,7 +697,7 @@ nano_qt::block_viewer::block_viewer (nano_qt::wallet & wallet_a) : if (!error) { auto transaction (this->wallet.node.store.tx_begin_read ()); - if (this->wallet.node.store.block_exists (transaction, block)) + if (this->wallet.node.store.block.exists (transaction, block)) { rebroadcast->setEnabled (false); this->wallet.node.background ([this, block] () { @@ -719,11 +718,11 @@ void nano_qt::block_viewer::rebroadcast_action (nano::block_hash const & hash_a) { auto done (true); auto transaction (wallet.node.ledger.store.tx_begin_read ()); - auto block (wallet.node.store.block_get (transaction, hash_a)); + auto block (wallet.node.store.block.get (transaction, hash_a)); if (block != nullptr) { wallet.node.network.flood_block (block); - auto successor (wallet.node.store.block_successor (transaction, hash_a)); + auto successor (wallet.node.store.block.successor (transaction, hash_a)); if (!successor.is_zero ()) { done = false; @@ -778,7 +777,7 @@ nano_qt::account_viewer::account_viewer (nano_qt::wallet & wallet_a) : auto final_text (std::string ("Balance (NANO): ") + wallet.format_balance (balance.first)); if (!balance.second.is_zero ()) { - final_text += "\nPending: " + wallet.format_balance (balance.second); + final_text += "\nReady to receive: " + wallet.format_balance (balance.second); } balance_label->setText (QString (final_text.c_str ())); } @@ -846,7 +845,7 @@ void nano_qt::stats_viewer::refresh_stats () if (json) { // Format the stat data to make totals and values easier to read - BOOST_FOREACH (const boost::property_tree::ptree::value_type & child, json->get_child ("entries")) + BOOST_FOREACH (boost::property_tree::ptree::value_type const & child, json->get_child ("entries")) { auto time = child.second.get ("time"); auto type = child.second.get ("type"); @@ -861,7 +860,7 @@ void nano_qt::stats_viewer::refresh_stats () if (type == "traffic_udp" || type == "traffic_tcp") { - const std::vector units = { " bytes", " KB", " MB", " GB", " TB", " PB" }; + std::vector const units = { " bytes", " KB", " MB", " GB", " TB", " PB" }; double bytes = std::stod (value); auto index = bytes == 0 ? 0 : std::min (units.size () - 1, static_cast (std::floor (std::log2 (bytes) / 10))); std::string unit = units[index]; @@ -923,7 +922,7 @@ std::string nano_qt::status::text () std::string count_string; { auto size (wallet.wallet_m->wallets.node.ledger.cache.block_count.load ()); - unchecked = wallet.wallet_m->wallets.node.store.unchecked_count (wallet.wallet_m->wallets.node.store.tx_begin_read ()); + unchecked = wallet.wallet_m->wallets.node.store.unchecked.count (wallet.wallet_m->wallets.node.store.tx_begin_read ()); count_string = std::to_string (size); } @@ -1290,7 +1289,7 @@ void nano_qt::wallet::start () this_l->push_main_stack (this_l->send_blocks_window); } }); - node.observers.blocks.add ([this_w] (nano::election_status const & status_a, std::vector const & votes_a, nano::account const & account_a, nano::uint128_t const & amount_a, bool) { + node.observers.blocks.add ([this_w] (nano::election_status const & status_a, std::vector const & votes_a, nano::account const & account_a, nano::uint128_t const & amount_a, bool, bool) { if (auto this_l = this_w.lock ()) { this_l->application.postEvent (&this_l->processor, new eventloop_event ([this_w, status_a, account_a] () { @@ -1458,16 +1457,8 @@ void nano_qt::wallet::change_rendering_ratio (nano::uint128_t const & rendering_ std::string nano_qt::wallet::format_balance (nano::uint128_t const & balance) const { auto balance_str = nano::amount (balance).format_balance (rendering_ratio, 3, false); - auto unit = std::string ("NANO"); - if (rendering_ratio == nano::banoshi_ratio) - { - unit = std::string ("knano"); - } - else if (rendering_ratio == nano::RAW_ratio) - { - unit = std::string ("nano"); - } - else if (rendering_ratio == nano::raw_ratio) + auto unit = std::string ("nano"); + if (rendering_ratio == nano::raw_ratio) { unit = std::string ("raw"); } @@ -1697,7 +1688,7 @@ void nano_qt::settings::refresh_representative () { auto transaction (this->wallet.wallet_m->wallets.node.store.tx_begin_read ()); nano::account_info info; - auto error (wallet.node.store.account_get (transaction, this->wallet.account, info)); + auto error (wallet.node.store.account.get (transaction, this->wallet.account, info)); if (!error) { current_representative->setText (QString (info.representative.to_account ().c_str ())); @@ -1751,8 +1742,6 @@ nano_qt::advanced_actions::advanced_actions (nano_qt::wallet & wallet_a) : scale_layout (new QHBoxLayout), scale_label (new QLabel ("Scale:")), ratio_group (new QButtonGroup), - mnano_unit (new QRadioButton ("Mnano")), - knano_unit (new QRadioButton ("knano")), nano_unit (new QRadioButton ("nano")), raw_unit (new QRadioButton ("raw")), back (new QPushButton ("Back")), @@ -1775,17 +1764,11 @@ nano_qt::advanced_actions::advanced_actions (nano_qt::wallet & wallet_a) : peers_back (new QPushButton ("Back")), wallet (wallet_a) { - ratio_group->addButton (mnano_unit); - ratio_group->addButton (knano_unit); ratio_group->addButton (nano_unit); + ratio_group->setId (nano_unit, ratio_group->buttons ().size () - 1); ratio_group->addButton (raw_unit); - ratio_group->setId (mnano_unit, 0); - ratio_group->setId (knano_unit, 1); - ratio_group->setId (nano_unit, 2); - ratio_group->setId (raw_unit, 3); + ratio_group->setId (raw_unit, ratio_group->buttons ().size () - 1); scale_layout->addWidget (scale_label); - scale_layout->addWidget (mnano_unit); - scale_layout->addWidget (knano_unit); scale_layout->addWidget (nano_unit); scale_layout->addWidget (raw_unit); scale_window->setLayout (scale_layout); @@ -1839,46 +1822,28 @@ nano_qt::advanced_actions::advanced_actions (nano_qt::wallet & wallet_a) : layout->addWidget (back); window->setLayout (layout); - QObject::connect (mnano_unit, &QRadioButton::toggled, [this] () { - if (mnano_unit->isChecked ()) - { - QSettings ().setValue (saved_ratio_key, ratio_group->id (mnano_unit)); - this->wallet.change_rendering_ratio (nano::BAN_ratio); - } - }); - QObject::connect (knano_unit, &QRadioButton::toggled, [this] () { - if (knano_unit->isChecked ()) - { - QSettings ().setValue (saved_ratio_key, ratio_group->id (knano_unit)); - this->wallet.change_rendering_ratio (nano::banoshi_ratio); - } - }); QObject::connect (nano_unit, &QRadioButton::toggled, [this] () { if (nano_unit->isChecked ()) { + this->wallet.change_rendering_ratio (nano::BAN_ratio); QSettings ().setValue (saved_ratio_key, ratio_group->id (nano_unit)); - this->wallet.change_rendering_ratio (nano::RAW_ratio); } }); QObject::connect (raw_unit, &QRadioButton::toggled, [this] () { if (raw_unit->isChecked ()) { - QSettings ().setValue (saved_ratio_key, ratio_group->id (raw_unit)); this->wallet.change_rendering_ratio (nano::raw_ratio); + QSettings ().setValue (saved_ratio_key, ratio_group->id (raw_unit)); } }); - auto selected_ratio_id (QSettings ().value (saved_ratio_key, ratio_group->id (mnano_unit)).toInt ()); - auto selected_ratio_button = ratio_group->button (selected_ratio_id); - debug_assert (selected_ratio_button != nullptr); - - if (selected_ratio_button) + auto selected_ratio_button = ratio_group->button (QSettings ().value (saved_ratio_key).toInt ()); + if (selected_ratio_button == nullptr) { - selected_ratio_button->click (); - } - else - { - mnano_unit->click (); + selected_ratio_button = nano_unit; } + debug_assert (selected_ratio_button != nullptr); + selected_ratio_button->click (); + QSettings ().setValue (saved_ratio_key, ratio_group->id (selected_ratio_button)); QObject::connect (wallet_refresh, &QPushButton::released, [this] () { this->wallet.accounts.refresh (); this->wallet.accounts.refresh_wallet_balance (); @@ -1943,7 +1908,7 @@ nano_qt::advanced_actions::advanced_actions (nano_qt::wallet & wallet_a) : }); bootstrap->setToolTip ("Multi-connection bootstrap to random peers"); - search_for_receivables->setToolTip ("Search for pending blocks"); + search_for_receivables->setToolTip ("Search for ready to be received blocks"); create_block->setToolTip ("Create block in JSON format"); enter_block->setToolTip ("Enter block in JSON format"); } @@ -1952,7 +1917,7 @@ void nano_qt::advanced_actions::refresh_peers () { peers_model->removeRows (0, peers_model->rowCount ()); auto list (wallet.node.network.list (std::numeric_limits::max ())); - std::sort (list.begin (), list.end (), [] (const auto & lhs, const auto & rhs) { + std::sort (list.begin (), list.end (), [] (auto const & lhs, auto const & rhs) { return lhs->get_endpoint () < rhs->get_endpoint (); }); for (auto i (list.begin ()), n (list.end ()); i != n; ++i) @@ -1982,7 +1947,7 @@ void nano_qt::advanced_actions::refresh_ledger () { ledger_model->removeRows (0, ledger_model->rowCount ()); auto transaction (wallet.node.store.tx_begin_read ()); - for (auto i (wallet.node.ledger.store.accounts_begin (transaction)), j (wallet.node.ledger.store.accounts_end ()); i != j; ++i) + for (auto i (wallet.node.ledger.store.account.begin (transaction)), j (wallet.node.ledger.store.account.end ()); i != j; ++i) { QList items; items.push_back (new QStandardItem (QString (i->first.to_account ().c_str ()))); @@ -2028,7 +1993,7 @@ nano_qt::block_entry::block_entry (nano_qt::wallet & wallet_a) : { show_label_ok (*status); this->status->setText (""); - if (!nano::work_validate_entry (*block_l)) + if (!this->wallet.node.network_params.work.validate_entry (*block_l)) { this->wallet.node.process_active (std::move (block_l)); } @@ -2259,14 +2224,14 @@ void nano_qt::block_creation::create_send () if (amount_l.number () <= balance) { nano::account_info info; - auto error (wallet.node.store.account_get (block_transaction, account_l, info)); + auto error (wallet.node.store.account.get (block_transaction, account_l, info)); (void)error; debug_assert (!error); nano::state_block send (account_l, info.head, info.representative, balance - amount_l.number (), destination_l, key, account_l, 0); nano::block_details details; details.is_send = true; details.epoch = info.epoch (); - auto const required_difficulty{ nano::work_threshold (send.work_version (), details) }; + auto const required_difficulty{ wallet.node.network_params.work.threshold (send.work_version (), details) }; if (wallet.node.work_generate_blocking (send, required_difficulty).is_initialized ()) { std::string block_l; @@ -2328,7 +2293,7 @@ void nano_qt::block_creation::create_receive () { auto transaction (wallet.node.wallets.tx_begin_read ()); auto block_transaction (wallet.node.store.tx_begin_read ()); - auto block_l (wallet.node.store.block_get (block_transaction, source_l)); + auto block_l (wallet.node.store.block.get (block_transaction, source_l)); if (block_l != nullptr) { auto const & destination (wallet.node.ledger.block_destination (block_transaction, *block_l)); @@ -2336,10 +2301,10 @@ void nano_qt::block_creation::create_receive () { nano::pending_key pending_key (destination, source_l); nano::pending_info pending; - if (!wallet.node.store.pending_get (block_transaction, pending_key, pending)) + if (!wallet.node.store.pending.get (block_transaction, pending_key, pending)) { nano::account_info info; - auto error (wallet.node.store.account_get (block_transaction, pending_key.account, info)); + auto error (wallet.node.store.account.get (block_transaction, pending_key.account, info)); if (!error) { nano::raw_key key; @@ -2350,7 +2315,7 @@ void nano_qt::block_creation::create_receive () nano::block_details details; details.is_receive = true; details.epoch = std::max (info.epoch (), pending.epoch); - auto required_difficulty{ nano::work_threshold (receive.work_version (), details) }; + auto required_difficulty{ wallet.node.network_params.work.threshold (receive.work_version (), details) }; if (wallet.node.work_generate_blocking (receive, required_difficulty).is_initialized ()) { std::string block_l; @@ -2388,7 +2353,7 @@ void nano_qt::block_creation::create_receive () else { show_label_error (*status); - status->setText ("Source block is not pending to receive"); + status->setText ("Source block is not ready to be received"); } } else @@ -2423,7 +2388,7 @@ void nano_qt::block_creation::create_change () auto transaction (wallet.node.wallets.tx_begin_read ()); auto block_transaction (wallet.node.store.tx_begin_read ()); nano::account_info info; - auto error (wallet.node.store.account_get (block_transaction, account_l, info)); + auto error (wallet.node.store.account.get (block_transaction, account_l, info)); if (!error) { nano::raw_key key; @@ -2433,7 +2398,7 @@ void nano_qt::block_creation::create_change () nano::state_block change (account_l, info.head, representative_l, info.balance, 0, key, account_l, 0); nano::block_details details; details.epoch = info.epoch (); - auto const required_difficulty{ nano::work_threshold (change.work_version (), details) }; + auto const required_difficulty{ wallet.node.network_params.work.threshold (change.work_version (), details) }; if (wallet.node.work_generate_blocking (change, required_difficulty).is_initialized ()) { std::string block_l; @@ -2493,7 +2458,7 @@ void nano_qt::block_creation::create_open () { auto transaction (wallet.node.wallets.tx_begin_read ()); auto block_transaction (wallet.node.store.tx_begin_read ()); - auto block_l (wallet.node.store.block_get (block_transaction, source_l)); + auto block_l (wallet.node.store.block.get (block_transaction, source_l)); if (block_l != nullptr) { auto const & destination (wallet.node.ledger.block_destination (block_transaction, *block_l)); @@ -2501,10 +2466,10 @@ void nano_qt::block_creation::create_open () { nano::pending_key pending_key (destination, source_l); nano::pending_info pending; - if (!wallet.node.store.pending_get (block_transaction, pending_key, pending)) + if (!wallet.node.store.pending.get (block_transaction, pending_key, pending)) { nano::account_info info; - auto error (wallet.node.store.account_get (block_transaction, pending_key.account, info)); + auto error (wallet.node.store.account.get (block_transaction, pending_key.account, info)); if (error) { nano::raw_key key; @@ -2515,7 +2480,7 @@ void nano_qt::block_creation::create_open () nano::block_details details; details.is_receive = true; details.epoch = pending.epoch; - auto const required_difficulty{ nano::work_threshold (open.work_version (), details) }; + auto const required_difficulty{ wallet.node.network_params.work.threshold (open.work_version (), details) }; if (wallet.node.work_generate_blocking (open, required_difficulty).is_initialized ()) { std::string block_l; @@ -2553,7 +2518,7 @@ void nano_qt::block_creation::create_open () else { show_label_error (*status); - status->setText ("Source block is not pending to receive"); + status->setText ("Source block is not ready to be received"); } } else diff --git a/nano/qt/qt.hpp b/nano/qt/qt.hpp index 4147dbc95d..fd94052bbd 100644 --- a/nano/qt/qt.hpp +++ b/nano/qt/qt.hpp @@ -66,8 +66,6 @@ class advanced_actions QHBoxLayout * scale_layout; QLabel * scale_label; QButtonGroup * ratio_group; - QRadioButton * mnano_unit; - QRadioButton * knano_unit; QRadioButton * nano_unit; QRadioButton * raw_unit; QPushButton * back; diff --git a/nano/qt_system/entry.cpp b/nano/qt_system/entry.cpp deleted file mode 100644 index ff13982b6a..0000000000 --- a/nano/qt_system/entry.cpp +++ /dev/null @@ -1,49 +0,0 @@ -#include -#include -#include -#include -#include -#include - -#include - -#include -int main (int argc, char ** argv) -{ - nano::force_nano_dev_network (); - nano::node_singleton_memory_pool_purge_guard memory_pool_cleanup_guard; - QApplication application (argc, argv); - QCoreApplication::setOrganizationName ("Banano"); - QCoreApplication::setOrganizationDomain ("nano.org"); - QCoreApplication::setApplicationName ("Banano Wallet"); - nano_qt::eventloop_processor processor; - const uint16_t count (16); - nano::system system (count); - nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); - std::unique_ptr client_tabs (new QTabWidget); - std::vector> guis; - for (auto i (0); i < count; ++i) - { - auto wallet (system.nodes[i]->wallets.create (nano::random_wallet_id ())); - nano::keypair key; - wallet->insert_adhoc (key.prv); - guis.push_back (std::make_unique (application, processor, *system.nodes[i], wallet, key.pub)); - client_tabs->addTab (guis.back ()->client_window, boost::str (boost::format ("Wallet %1%") % i).c_str ()); - } - client_tabs->show (); - QObject::connect (&application, &QApplication::aboutToQuit, [&] () { - system.stop (); - }); - int result; - try - { - result = application.exec (); - } - catch (...) - { - result = -1; - debug_assert (false); - } - runner.join (); - return result; -} diff --git a/nano/qt_test/qt.cpp b/nano/qt_test/qt.cpp index 58c650daa6..6ca122007c 100644 --- a/nano/qt_test/qt.cpp +++ b/nano/qt_test/qt.cpp @@ -1,5 +1,5 @@ -#include #include +#include #include #include @@ -104,7 +104,7 @@ TEST (wallet, startup_balance) wallet->needs_balance_refresh = true; wallet->start (); wallet->application.processEvents (QEventLoop::AllEvents); - ASSERT_EQ ("Balance: 0 NANO", wallet->self.balance_label->text ().toStdString ()); + ASSERT_EQ ("Balance: 0 nano", wallet->self.balance_label->text ().toStdString ()); } TEST (wallet, select_account) @@ -291,9 +291,9 @@ TEST (wallet, send) { nano_qt::eventloop_processor processor; nano::system system (2); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::public_key key1 (system.wallet (1)->insert_adhoc (nano::keypair ().prv)); - auto account (nano::dev_genesis_key.pub); + auto account (nano::dev::genesis_key.pub); auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); ASSERT_NE (wallet->rendering_ratio, nano::raw_ratio); @@ -324,13 +324,13 @@ TEST (wallet, send_locked) { nano_qt::eventloop_processor processor; nano::system system (1); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key1; { auto transaction (system.wallet (0)->wallets.tx_begin_write ()); system.wallet (0)->enter_password (transaction, "0"); } - auto account (nano::dev_genesis_key.pub); + auto account (nano::dev::genesis_key.pub); auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); QTest::mouseClick (wallet->send_blocks, Qt::LeftButton); @@ -350,7 +350,7 @@ TEST (wallet, process_block) nano_qt::eventloop_processor processor; nano::system system (1); nano::account account; - nano::block_hash latest (system.nodes[0]->latest (nano::genesis_account)); + nano::block_hash latest (system.nodes[0]->latest (nano::dev::genesis->account ())); system.wallet (0)->insert_adhoc (nano::keypair ().prv); { auto transaction (system.nodes[0]->wallets.tx_begin_read ()); @@ -365,7 +365,7 @@ TEST (wallet, process_block) QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); QTest::mouseClick (wallet->advanced.enter_block, Qt::LeftButton); ASSERT_EQ (wallet->block_entry.window, wallet->main_stack->currentWidget ()); - nano::send_block send (latest, key1.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); + nano::send_block send (latest, key1.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); std::string previous; send.hashables.previous.encode_hex (previous); std::string balance; @@ -380,7 +380,7 @@ TEST (wallet, process_block) { auto transaction (system.nodes[0]->store.tx_begin_read ()); system.deadline_set (10s); - while (system.nodes[0]->store.block_exists (transaction, send.hash ())) + while (system.nodes[0]->store.block.exists (transaction, send.hash ())) { ASSERT_NO_ERROR (system.poll ()); } @@ -394,16 +394,16 @@ TEST (wallet, create_send) nano_qt::eventloop_processor processor; nano::keypair key; nano::system system (1); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - auto account (nano::dev_genesis_key.pub); + auto account (nano::dev::genesis_key.pub); auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); wallet->client_window->show (); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); QTest::mouseClick (wallet->advanced.create_block, Qt::LeftButton); QTest::mouseClick (wallet->block_creation.send, Qt::LeftButton); - QTest::keyClicks (wallet->block_creation.account, nano::dev_genesis_key.pub.to_account ().c_str ()); + QTest::keyClicks (wallet->block_creation.account, nano::dev::genesis_key.pub.to_account ().c_str ()); QTest::keyClicks (wallet->block_creation.amount, "100000000000000000000"); QTest::keyClicks (wallet->block_creation.destination, key.pub.to_account ().c_str ()); QTest::mouseClick (wallet->block_creation.create, Qt::LeftButton); @@ -424,14 +424,14 @@ TEST (wallet, create_open_receive) nano_qt::eventloop_processor processor; nano::keypair key; nano::system system (1); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 100); - nano::block_hash latest1 (system.nodes[0]->latest (nano::dev_genesis_key.pub)); - system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 100); - nano::block_hash latest2 (system.nodes[0]->latest (nano::dev_genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 100); + nano::block_hash latest1 (system.nodes[0]->latest (nano::dev::genesis_key.pub)); + system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 100); + nano::block_hash latest2 (system.nodes[0]->latest (nano::dev::genesis_key.pub)); ASSERT_NE (latest1, latest2); system.wallet (0)->insert_adhoc (key.prv); - auto account (nano::dev_genesis_key.pub); + auto account (nano::dev::genesis_key.pub); auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); wallet->client_window->show (); @@ -439,7 +439,7 @@ TEST (wallet, create_open_receive) QTest::mouseClick (wallet->advanced.create_block, Qt::LeftButton); wallet->block_creation.open->click (); QTest::keyClicks (wallet->block_creation.source, latest1.to_string ().c_str ()); - QTest::keyClicks (wallet->block_creation.representative, nano::dev_genesis_key.pub.to_account ().c_str ()); + QTest::keyClicks (wallet->block_creation.representative, nano::dev::genesis_key.pub.to_account ().c_str ()); QTest::mouseClick (wallet->block_creation.create, Qt::LeftButton); std::string json1 (wallet->block_creation.block->toPlainText ().toStdString ()); ASSERT_FALSE (json1.empty ()); @@ -473,15 +473,15 @@ TEST (wallet, create_change) nano_qt::eventloop_processor processor; nano::keypair key; nano::system system (1); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto account (nano::dev_genesis_key.pub); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto account (nano::dev::genesis_key.pub); auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); wallet->client_window->show (); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); QTest::mouseClick (wallet->advanced.create_block, Qt::LeftButton); wallet->block_creation.change->click (); - QTest::keyClicks (wallet->block_creation.account, nano::dev_genesis_key.pub.to_account ().c_str ()); + QTest::keyClicks (wallet->block_creation.account, nano::dev::genesis_key.pub.to_account ().c_str ()); QTest::keyClicks (wallet->block_creation.representative, key.pub.to_account ().c_str ()); wallet->block_creation.create->click (); std::string json (wallet->block_creation.block->toPlainText ().toStdString ()); @@ -498,7 +498,7 @@ TEST (wallet, create_change) TEST (history, short_text) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; @@ -513,30 +513,29 @@ TEST (history, short_text) account = system.account (transaction, 0); } auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); - auto store = nano::make_store (system.nodes[0]->logger, nano::unique_path ()); + auto store = nano::make_store (system.nodes[0]->logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); - nano::genesis genesis; - nano::ledger ledger (*store, system.nodes[0]->stats); + nano::ledger ledger (*store, system.nodes[0]->stats, nano::dev::constants); { auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); + store->initialize (transaction, ledger.cache); nano::keypair key; - auto latest (ledger.latest (transaction, nano::dev_genesis_key.pub)); - nano::send_block send (latest, nano::dev_genesis_key.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); + auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); + nano::send_block send (latest, nano::dev::genesis_key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); - nano::receive_block receive (send.hash (), send.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send.hash ())); + nano::receive_block receive (send.hash (), send.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code); - nano::change_block change (receive.hash (), key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive.hash ())); + nano::change_block change (receive.hash (), key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, change).code); } - nano_qt::history history (ledger, nano::dev_genesis_key.pub, *wallet); + nano_qt::history history (ledger, nano::dev::genesis_key.pub, *wallet); history.refresh (); ASSERT_EQ (4, history.model->rowCount ()); } TEST (history, pruned_source) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; @@ -551,29 +550,28 @@ TEST (history, pruned_source) account = system.account (transaction, 0); } auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); - auto store = nano::make_store (system.nodes[0]->logger, nano::unique_path ()); + auto store = nano::make_store (system.nodes[0]->logger, nano::unique_path (), nano::dev::constants); ASSERT_TRUE (!store->init_error ()); - nano::genesis genesis; - nano::ledger ledger (*store, system.nodes[0]->stats); + nano::ledger ledger (*store, system.nodes[0]->stats, nano::dev::constants); ledger.pruning = true; nano::block_hash next_pruning; // Basic pruning for legacy blocks. Previous block is pruned, source is pruned { auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - auto latest (ledger.latest (transaction, nano::dev_genesis_key.pub)); - nano::send_block send1 (latest, nano::dev_genesis_key.pub, nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); + store->initialize (transaction, ledger.cache); + auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); + nano::send_block send1 (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send1).code); - nano::send_block send2 (send1.hash (), key.pub, nano::genesis_amount - 200, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1.hash ())); + nano::send_block send2 (send1.hash (), key.pub, nano::dev::constants.genesis_amount - 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send2).code); - nano::receive_block receive (send2.hash (), send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send2.hash ())); + nano::receive_block receive (send2.hash (), send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2.hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, receive).code); nano::open_block open (send2.hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); ASSERT_EQ (1, ledger.pruning_action (transaction, send1.hash (), 2)); next_pruning = send2.hash (); } - nano_qt::history history1 (ledger, nano::dev_genesis_key.pub, *wallet); + nano_qt::history history1 (ledger, nano::dev::genesis_key.pub, *wallet); history1.refresh (); ASSERT_EQ (2, history1.model->rowCount ()); nano_qt::history history2 (ledger, key.pub, *wallet); @@ -591,8 +589,8 @@ TEST (history, pruned_source) // Pruning for state blocks. Previous block is pruned, source is pruned { auto transaction (store->tx_begin_write ()); - auto latest (ledger.latest (transaction, nano::dev_genesis_key.pub)); - nano::state_block send (nano::dev_genesis_key.pub, latest, nano::dev_genesis_key.pub, nano::genesis_amount - 200, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); + auto latest (ledger.latest (transaction, nano::dev::genesis_key.pub)); + nano::state_block send (nano::dev::genesis_key.pub, latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 200, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); auto latest_key (ledger.latest (transaction, key.pub)); nano::state_block receive (key.pub, latest_key, key.pub, 200, send.hash (), key.prv, key.pub, *system.work.generate (latest_key)); @@ -623,7 +621,7 @@ TEST (wallet, startup_work) uint64_t work1; { auto transaction (system.nodes[0]->wallets.tx_begin_read ()); - ASSERT_TRUE (wallet->wallet_m->store.work_get (transaction, nano::dev_genesis_key.pub, work1)); + ASSERT_TRUE (wallet->wallet_m->store.work_get (transaction, nano::dev::genesis_key.pub, work1)); } QTest::mouseClick (wallet->accounts_button, Qt::LeftButton); QTest::keyClicks (wallet->accounts.account_key_line, "34F0A37AAD20F4A260F0A5B3CB3D7FB50673212263E58A380BC10474BB039CE4"); @@ -634,7 +632,7 @@ TEST (wallet, startup_work) { ASSERT_NO_ERROR (system.poll ()); auto transaction (system.nodes[0]->wallets.tx_begin_read ()); - again = wallet->wallet_m->store.work_get (transaction, nano::dev_genesis_key.pub, work1); + again = wallet->wallet_m->store.work_get (transaction, nano::dev::genesis_key.pub, work1); } } @@ -655,7 +653,7 @@ TEST (wallet, block_viewer) ASSERT_NE (-1, wallet->advanced.layout->indexOf (wallet->advanced.block_viewer)); QTest::mouseClick (wallet->advanced.block_viewer, Qt::LeftButton); ASSERT_EQ (wallet->block_viewer.window, wallet->main_stack->currentWidget ()); - nano::block_hash latest (system.nodes[0]->latest (nano::genesis_account)); + nano::block_hash latest (system.nodes[0]->latest (nano::dev::genesis->account ())); QTest::keyClicks (wallet->block_viewer.hash, latest.to_string ().c_str ()); QTest::mouseClick (wallet->block_viewer.retrieve, Qt::LeftButton); ASSERT_FALSE (wallet->block_viewer.block->toPlainText ().toStdString ().empty ()); @@ -701,17 +699,17 @@ TEST (wallet, republish) { nano_qt::eventloop_processor processor; nano::system system (2); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key; nano::block_hash hash; { auto transaction (system.nodes[0]->store.tx_begin_write ()); - auto latest (system.nodes[0]->ledger.latest (transaction, nano::dev_genesis_key.pub)); - nano::send_block block (latest, key.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); + auto latest (system.nodes[0]->ledger.latest (transaction, nano::dev::genesis_key.pub)); + nano::send_block block (latest, key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); hash = block.hash (); ASSERT_EQ (nano::process_result::progress, system.nodes[0]->ledger.process (transaction, block).code); } - auto account (nano::dev_genesis_key.pub); + auto account (nano::dev::genesis_key.pub); auto wallet (std::make_shared (*test_application, processor, *system.nodes[0], system.wallet (0), account)); wallet->start (); QTest::mouseClick (wallet->show_advanced, Qt::LeftButton); @@ -720,9 +718,9 @@ TEST (wallet, republish) ASSERT_EQ (wallet->block_viewer.window, wallet->main_stack->currentWidget ()); QTest::keyClicks (wallet->block_viewer.hash, hash.to_string ().c_str ()); QTest::mouseClick (wallet->block_viewer.rebroadcast, Qt::LeftButton); - ASSERT_FALSE (system.nodes[1]->balance (nano::dev_genesis_key.pub).is_zero ()); + ASSERT_FALSE (system.nodes[1]->balance (nano::dev::genesis_key.pub).is_zero ()); system.deadline_set (10s); - while (system.nodes[1]->balance (nano::dev_genesis_key.pub).is_zero ()) + while (system.nodes[1]->balance (nano::dev::genesis_key.pub).is_zero ()) { ASSERT_NO_ERROR (system.poll ()); } @@ -740,7 +738,7 @@ TEST (wallet, ignore_empty_adhoc) ASSERT_EQ (wallet->advanced.window, wallet->main_stack->currentWidget ()); QTest::mouseClick (wallet->accounts_button, Qt::LeftButton); ASSERT_EQ (wallet->accounts.window, wallet->main_stack->currentWidget ()); - QTest::keyClicks (wallet->accounts.account_key_line, nano::dev_genesis_key.prv.to_string ().c_str ()); + QTest::keyClicks (wallet->accounts.account_key_line, nano::dev::genesis_key.prv.to_string ().c_str ()); QTest::mouseClick (wallet->accounts.account_key_button, Qt::LeftButton); ASSERT_EQ (1, wallet->accounts.model->rowCount ()); ASSERT_EQ (0, wallet->accounts.account_key_line->text ().length ()); @@ -837,7 +835,7 @@ TEST (wallet, seed_work_generation) ASSERT_NO_ERROR (ec); } auto transaction (system.nodes[0]->store.tx_begin_read ()); - ASSERT_GE (nano::work_difficulty (nano::work_version::work_1, system.nodes[0]->ledger.latest_root (transaction, pub), work), system.nodes[0]->default_difficulty (nano::work_version::work_1)); + ASSERT_GE (nano::dev::network_params.work.difficulty (nano::work_version::work_1, system.nodes[0]->ledger.latest_root (transaction, pub), work), system.nodes[0]->default_difficulty (nano::work_version::work_1)); } TEST (wallet, backup_seed) @@ -906,8 +904,8 @@ TEST (wallet, DISABLED_synchronizing) wallet->start (); { auto transaction (system1.nodes[0]->store.tx_begin_write ()); - auto latest (system1.nodes[0]->ledger.latest (transaction, nano::genesis_account)); - nano::send_block send (latest, key1, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system1.work.generate (latest)); + auto latest (system1.nodes[0]->ledger.latest (transaction, nano::dev::genesis->account ())); + nano::send_block send (latest, key1, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system1.work.generate (latest)); system1.nodes[0]->ledger.process (transaction, send); } ASSERT_EQ (0, wallet->active_status.active.count (nano_qt::status_types::synchronizing)); @@ -938,9 +936,9 @@ TEST (wallet, epoch_2_validation) ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_1)); ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_2)); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - auto account (nano::dev_genesis_key.pub); + auto account (nano::dev::genesis_key.pub); auto wallet (std::make_shared (*test_application, processor, *node, system.wallet (0), account)); wallet->start (); wallet->client_window->show (); @@ -964,7 +962,7 @@ TEST (wallet, epoch_2_validation) auto do_send = [&] (nano::public_key const & destination) -> nano::block_hash { wallet->block_creation.send->click (); - wallet->block_creation.account->setText (nano::dev_genesis_key.pub.to_account ().c_str ()); + wallet->block_creation.account->setText (nano::dev::genesis_key.pub.to_account ().c_str ()); wallet->block_creation.amount->setText ("1"); wallet->block_creation.destination->setText (destination.to_account ().c_str ()); return create_and_process (); @@ -1002,6 +1000,6 @@ TEST (wallet, epoch_2_validation) do_open (send1, key.pub); auto send2 = do_send (key.pub); do_receive (send2); - do_change (key.pub, nano::dev_genesis_key.pub); + do_change (key.pub, nano::dev::genesis_key.pub); } } diff --git a/nano/rpc/rpc.cpp b/nano/rpc/rpc.cpp index d3bdb7b8db..e98601f59a 100644 --- a/nano/rpc/rpc.cpp +++ b/nano/rpc/rpc.cpp @@ -1,5 +1,6 @@ #include #include +#include #include #include @@ -82,12 +83,10 @@ std::unique_ptr nano::get_rpc (boost::asio::io_context & io_ctx_a, na { std::unique_ptr impl; - if (config_a.secure.enable) + if (config_a.tls_config && config_a.tls_config->enable_https) { #ifdef NANO_SECURE_RPC impl = std::make_unique (io_ctx_a, config_a, rpc_handler_interface_a); -#else - std::cerr << "RPC configured for TLS, but the node is not compiled with TLS support" << std::endl; #endif } else diff --git a/nano/rpc/rpc_connection_secure.cpp b/nano/rpc/rpc_connection_secure.cpp index 64626b69b4..6287ed9931 100644 --- a/nano/rpc/rpc_connection_secure.cpp +++ b/nano/rpc/rpc_connection_secure.cpp @@ -20,13 +20,13 @@ void nano::rpc_connection_secure::parse_connection () })); } -void nano::rpc_connection_secure::on_shutdown (const boost::system::error_code & error) +void nano::rpc_connection_secure::on_shutdown (boost::system::error_code const & error) { // No-op. We initiate the shutdown (since the RPC server kills the connection after each request) // and we'll thus get an expected EOF error. If the client disconnects, a short-read error will be expected. } -void nano::rpc_connection_secure::handle_handshake (const boost::system::error_code & error) +void nano::rpc_connection_secure::handle_handshake (boost::system::error_code const & error) { if (!error) { diff --git a/nano/rpc/rpc_connection_secure.hpp b/nano/rpc/rpc_connection_secure.hpp index 61ed08e7fd..13e9287d20 100644 --- a/nano/rpc/rpc_connection_secure.hpp +++ b/nano/rpc/rpc_connection_secure.hpp @@ -17,9 +17,9 @@ class rpc_connection_secure : public rpc_connection void parse_connection () override; void write_completion_handler (std::shared_ptr const & rpc) override; /** The TLS handshake callback */ - void handle_handshake (const boost::system::error_code & error); + void handle_handshake (boost::system::error_code const & error); /** The TLS async shutdown callback */ - void on_shutdown (const boost::system::error_code & error); + void on_shutdown (boost::system::error_code const & error); private: boost::asio::ssl::stream stream; diff --git a/nano/rpc/rpc_request_processor.hpp b/nano/rpc/rpc_request_processor.hpp index 0b0da628e7..b6788da515 100644 --- a/nano/rpc/rpc_request_processor.hpp +++ b/nano/rpc/rpc_request_processor.hpp @@ -22,17 +22,17 @@ struct ipc_connection struct rpc_request { - rpc_request (const std::string & action_a, const std::string & body_a, std::function response_a) : + rpc_request (std::string const & action_a, std::string const & body_a, std::function response_a) : action (action_a), body (body_a), response (response_a) { } - rpc_request (int rpc_api_version_a, const std::string & body_a, std::function response_a) : + rpc_request (int rpc_api_version_a, std::string const & body_a, std::function response_a) : rpc_api_version (rpc_api_version_a), body (body_a), response (response_a) { } - rpc_request (int rpc_api_version_a, const std::string & action_a, const std::string & body_a, std::function response_a) : + rpc_request (int rpc_api_version_a, std::string const & action_a, std::string const & body_a, std::function response_a) : rpc_api_version (rpc_api_version_a), action (action_a), body (body_a), response (response_a) { } @@ -64,8 +64,8 @@ class rpc_request_processor bool stopped{ false }; std::deque> requests; nano::condition_variable condition; - const std::string ipc_address; - const uint16_t ipc_port; + std::string const ipc_address; + uint16_t const ipc_port; std::thread thread; }; diff --git a/nano/rpc/rpc_secure.cpp b/nano/rpc/rpc_secure.cpp index ba088415c1..3f596a7cba 100644 --- a/nano/rpc/rpc_secure.cpp +++ b/nano/rpc/rpc_secure.cpp @@ -1,4 +1,5 @@ #include +#include #include #include @@ -7,112 +8,14 @@ #include -bool nano::rpc_secure::on_verify_certificate (bool preverified, boost::asio::ssl::verify_context & ctx) -{ - X509_STORE_CTX * cts = ctx.native_handle (); - auto error (X509_STORE_CTX_get_error (cts)); - switch (error) - { - case X509_V_ERR_UNABLE_TO_GET_ISSUER_CERT: - logger.always_log ("TLS: Unable to get issuer"); - break; - case X509_V_ERR_CERT_NOT_YET_VALID: - case X509_V_ERR_ERROR_IN_CERT_NOT_BEFORE_FIELD: - logger.always_log ("TLS: Certificate not yet valid"); - break; - case X509_V_ERR_CERT_HAS_EXPIRED: - case X509_V_ERR_ERROR_IN_CERT_NOT_AFTER_FIELD: - logger.always_log ("TLS: Certificate expired"); - break; - case X509_V_ERR_SELF_SIGNED_CERT_IN_CHAIN: - if (config.secure.verbose_logging) - { - logger.always_log ("TLS: self signed certificate in chain"); - } - - // Allow self-signed certificates - preverified = true; - break; - case X509_V_ERR_DEPTH_ZERO_SELF_SIGNED_CERT: - logger.always_log ("TLS: Self signed certificate not in the list of trusted certs (forgot to subject-hash certificate filename?)"); - break; - default: - break; - } - - if (config.secure.verbose_logging) - { - if (error != 0) - { - logger.always_log ("TLS: Error: ", X509_verify_cert_error_string (error)); - logger.always_log ("TLS: Error chain depth : ", X509_STORE_CTX_get_error_depth (cts)); - } - - X509 * cert = X509_STORE_CTX_get_current_cert (cts); - char subject_name[512]; - X509_NAME_oneline (X509_get_subject_name (cert), subject_name, sizeof (subject_name) - 1); - logger.always_log ("TLS: Verifying: ", subject_name); - logger.always_log ("TLS: Verification: ", preverified); - } - else if (!preverified) - { - logger.always_log ("TLS: Pre-verification failed. Turn on verbose logging for more information."); - } - - return preverified; -} - -void nano::rpc_secure::load_certs (boost::asio::ssl::context & context_a) -{ - try - { - // This is called if the key is password protected - context_a.set_password_callback ( - [this] (std::size_t, - boost::asio::ssl::context_base::password_purpose) { - return config.secure.server_key_passphrase; - }); - - // The following two options disables the session cache and enables stateless session resumption. - // This is necessary because of the way the RPC server abruptly terminate connections. - SSL_CTX_set_session_cache_mode (context_a.native_handle (), SSL_SESS_CACHE_OFF); - SSL_CTX_set_options (context_a.native_handle (), SSL_OP_NO_TICKET); - - context_a.set_options ( - boost::asio::ssl::context::default_workarounds | boost::asio::ssl::context::no_sslv2 | boost::asio::ssl::context::no_sslv3 | boost::asio::ssl::context::single_dh_use); - - context_a.use_certificate_chain_file (config.secure.server_cert_path); - context_a.use_private_key_file (config.secure.server_key_path, boost::asio::ssl::context::pem); - context_a.use_tmp_dh_file (config.secure.server_dh_path); - - // Verify client certificates? - if (!config.secure.client_certs_path.empty ()) - { - context_a.set_verify_mode (boost::asio::ssl::verify_fail_if_no_peer_cert | boost::asio::ssl::verify_peer); - context_a.add_verify_path (config.secure.client_certs_path); - context_a.set_verify_callback ([this] (auto preverified, auto & ctx) { - return this->on_verify_certificate (preverified, ctx); - }); - } - } - catch (boost::system::system_error const & err) - { - auto error (boost::str (boost::format ("Could not load certificate information: %1%. Make sure the paths in the secure rpc configuration are correct.") % err.what ())); - std::cerr << error << std::endl; - logger.always_log (error); - } -} - nano::rpc_secure::rpc_secure (boost::asio::io_context & context_a, nano::rpc_config const & config_a, nano::rpc_handler_interface & rpc_handler_interface_a) : - rpc (context_a, config_a, rpc_handler_interface_a), - ssl_context (boost::asio::ssl::context::tlsv12_server) + rpc (context_a, config_a, rpc_handler_interface_a) { - load_certs (ssl_context); } void nano::rpc_secure::accept () { - auto connection (std::make_shared (config, io_ctx, logger, rpc_handler_interface, this->ssl_context)); + auto connection (std::make_shared (config, io_ctx, logger, rpc_handler_interface, config.tls_config->ssl_context)); acceptor.async_accept (connection->socket, boost::asio::bind_executor (connection->strand, [this, connection] (boost::system::error_code const & ec) { if (ec != boost::asio::error::operation_aborted && acceptor.is_open ()) { diff --git a/nano/rpc/rpc_secure.hpp b/nano/rpc/rpc_secure.hpp index 2601614504..44ea22a9e0 100644 --- a/nano/rpc/rpc_secure.hpp +++ b/nano/rpc/rpc_secure.hpp @@ -1,8 +1,6 @@ #pragma once #include -#include - namespace boost { namespace asio @@ -23,17 +21,5 @@ class rpc_secure : public rpc /** Starts accepting connections */ void accept () override; - - /** Installs the server certificate, key and DH, and optionally sets up client certificate verification */ - void load_certs (boost::asio::ssl::context & ctx); - - /** - * If client certificates are used, this is called to verify them. - * @param preverified The TLS preverification status. The callback may revalidate, such as accepting self-signed certs. - */ - bool on_verify_certificate (bool preverified, boost::asio::ssl::verify_context & ctx); - - /** The context needs to be shared between sessions to make resumption work */ - boost::asio::ssl::context ssl_context; }; } diff --git a/nano/rpc_test/rpc.cpp b/nano/rpc_test/rpc.cpp index 1ab8010f1c..71ed79e736 100644 --- a/nano/rpc_test/rpc.cpp +++ b/nano/rpc_test/rpc.cpp @@ -5,9 +5,9 @@ #include #include #include -#include #include #include +#include #include #include @@ -17,6 +17,7 @@ #include #include +#include using namespace std::chrono_literals; @@ -113,22 +114,43 @@ std::shared_ptr add_ipc_enabled_node (nano::system & system) return add_ipc_enabled_node (system, node_config); } -void reset_confirmation_height (nano::block_store & store, nano::account const & account) +void reset_confirmation_height (nano::store & store, nano::account const & account) { auto transaction = store.tx_begin_write (); nano::confirmation_height_info confirmation_height_info; - if (!store.confirmation_height_get (transaction, account, confirmation_height_info)) + if (!store.confirmation_height.get (transaction, account, confirmation_height_info)) { - store.confirmation_height_clear (transaction, account); + store.confirmation_height.clear (transaction, account); } } -void check_block_response_count (nano::system & system, nano::rpc & rpc, boost::property_tree::ptree & request, uint64_t size_count) +void wait_response_impl (nano::system & system, std::shared_ptr const & rpc, boost::property_tree::ptree & request, std::chrono::duration const & time, boost::property_tree::ptree & response_json) { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); + test_response response (request, rpc->config.port, system.io_ctx); + ASSERT_TIMELY (time, response.status != 0); ASSERT_EQ (200, response.status); - ASSERT_EQ (size_count, response.json.get_child ("blocks").front ().second.size ()); + response_json = response.json; +} + +boost::property_tree::ptree wait_response (nano::system & system, std::shared_ptr const & rpc, boost::property_tree::ptree & request, std::chrono::duration const & time = 5s) +{ + boost::property_tree::ptree response_json; + wait_response_impl (system, rpc, request, time, response_json); + return response_json; +} + +void check_block_response_count (nano::system & system, std::shared_ptr const & rpc, boost::property_tree::ptree & request, uint64_t size_count) +{ + auto response (wait_response (system, rpc, request)); + auto & blocks = response.get_child ("blocks"); + if (size_count > 0) + { + ASSERT_EQ (size_count, blocks.front ().second.size ()); + } + else + { + ASSERT_TRUE (blocks.empty ()); + } } class scoped_io_thread_name_change @@ -154,6 +176,37 @@ class scoped_io_thread_name_change nano::thread_role::set (nano::thread_role::name::io); } }; + +class rpc_context +{ +public: + rpc_context (std::unique_ptr & ipc_server_a, std::unique_ptr & ipc_rpc_processor_a, std::unique_ptr & node_rpc_config_a, std::unique_ptr & io_scope_a) + { + ipc_server = std::move (ipc_server_a); + ipc_rpc_processor = std::move (ipc_rpc_processor_a); + node_rpc_config = std::move (node_rpc_config_a); + io_scope = std::move (io_scope_a); + } + + std::unique_ptr ipc_server; + std::unique_ptr ipc_rpc_processor; + std::unique_ptr node_rpc_config; + std::unique_ptr io_scope; +}; + +std::tuple, std::unique_ptr> add_rpc (nano::system & system, std::shared_ptr const & node_a) +{ + auto scoped_thread_name_io (std::make_unique ()); + auto node_rpc_config (std::make_unique ()); + auto ipc_server (std::make_unique (*node_a, *node_rpc_config)); + nano::rpc_config rpc_config (node_a->network_params.network, nano::get_available_port (), true); + rpc_config.rpc_process.ipc_port = node_a->config.ipc_config.transport_tcp.port; + auto ipc_rpc_processor (std::make_unique (system.io_ctx, rpc_config)); + auto rpc (std::make_shared (system.io_ctx, rpc_config, *ipc_rpc_processor)); + rpc->start (); + auto rpc_ctx (std::make_unique (ipc_server, ipc_rpc_processor, node_rpc_config, scoped_thread_name_io)); + return std::make_tuple (rpc, std::move (rpc_ctx)); +} } TEST (rpc, wrapped_task) @@ -188,49 +241,38 @@ TEST (rpc, account_balance) nano::state_block_builder builder; auto send1 = builder.make_block () - .account (nano::dev_genesis_key.pub) - .previous (nano::genesis_hash) - .representative (nano::dev_genesis_key.pub) - .balance (nano::genesis_amount - 1) - .link (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*system.work.generate (nano::genesis_hash)) + .account (nano::dev::genesis_key.pub) + .previous (nano::dev::genesis->hash ()) + .representative (nano::dev::genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - 1) + .link (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*system.work.generate (nano::dev::genesis->hash ())) .build (); ASSERT_EQ (nano::process_result::progress, node->process (*send1).code); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "account_balance"); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); // The send and pending should be unconfirmed { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string balance_text (response.json.get ("balance")); + auto response (wait_response (system, rpc, request)); + std::string balance_text (response.get ("balance")); ASSERT_EQ ("340282366920938463463374607431768211455", balance_text); - std::string pending_text (response.json.get ("pending")); + std::string pending_text (response.get ("pending")); ASSERT_EQ ("0", pending_text); } request.put ("include_only_confirmed", false); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string balance_text (response.json.get ("balance")); + auto response (wait_response (system, rpc, request)); + std::string balance_text (response.get ("balance")); ASSERT_EQ ("340282366920938463463374607431768211454", balance_text); - std::string pending_text (response.json.get ("pending")); + std::string pending_text (response.get ("pending")); ASSERT_EQ ("1", pending_text); } } @@ -239,21 +281,12 @@ TEST (rpc, account_block_count) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, context] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "account_block_count"); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string block_count_text (response.json.get ("block_count")); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); + auto response (wait_response (system, rpc, request)); + std::string block_count_text (response.get ("block_count")); ASSERT_EQ ("1", block_count_text); } @@ -261,63 +294,41 @@ TEST (rpc, account_create) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "account_create"); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); - test_response response0 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response0.status != 0); - ASSERT_EQ (200, response0.status); - auto account_text0 (response0.json.get ("account")); + auto response0 (wait_response (system, rpc, request)); + auto account_text0 (response0.get ("account")); nano::account account0; ASSERT_FALSE (account0.decode_account (account_text0)); ASSERT_TRUE (system.wallet (0)->exists (account0)); constexpr uint64_t max_index (std::numeric_limits::max ()); request.put ("index", max_index); - test_response response1 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response1.status != 0); - ASSERT_EQ (200, response1.status); - auto account_text1 (response1.json.get ("account")); + auto response1 (wait_response (system, rpc, request, 10s)); + auto account_text1 (response1.get ("account")); nano::account account1; ASSERT_FALSE (account1.decode_account (account_text1)); ASSERT_TRUE (system.wallet (0)->exists (account1)); request.put ("index", max_index + 1); - test_response response2 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response2.status != 0); - ASSERT_EQ (200, response2.status); - ASSERT_EQ (std::error_code (nano::error_common::invalid_index).message (), response2.json.get ("error")); + auto response2 (wait_response (system, rpc, request)); + ASSERT_EQ (std::error_code (nano::error_common::invalid_index).message (), response2.get ("error")); } TEST (rpc, account_weight) { nano::keypair key; nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - nano::block_hash latest (node1.latest (nano::dev_genesis_key.pub)); - nano::change_block block (latest, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - ASSERT_EQ (nano::process_result::progress, node1.process (block).code); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + nano::block_hash latest (node1->latest (nano::dev::genesis_key.pub)); + nano::change_block block (latest, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + ASSERT_EQ (nano::process_result::progress, node1->process (block).code); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "account_weight"); request.put ("account", key.pub.to_account ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string balance_text (response.json.get ("weight")); + auto response (wait_response (system, rpc, request)); + std::string balance_text (response.get ("weight")); ASSERT_EQ ("340282366920938463463374607431768211455", balance_text); } @@ -325,25 +336,16 @@ TEST (rpc, wallet_contains) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "wallet_contains"); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string exists_text (response.json.get ("exists")); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); + auto response (wait_response (system, rpc, request)); + std::string exists_text (response.get ("exists")); ASSERT_EQ ("1", exists_text); } @@ -351,24 +353,15 @@ TEST (rpc, wallet_doesnt_contain) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "wallet_contains"); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string exists_text (response.json.get ("exists")); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); + auto response (wait_response (system, rpc, request)); + std::string exists_text (response.get ("exists")); ASSERT_EQ ("0", exists_text); } @@ -376,21 +369,12 @@ TEST (rpc, validate_account_number) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "validate_account_number"); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - std::string exists_text (response.json.get ("valid")); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); + auto response (wait_response (system, rpc, request)); + std::string exists_text (response.get ("valid")); ASSERT_EQ ("1", exists_text); } @@ -398,25 +382,15 @@ TEST (rpc, validate_account_invalid) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); std::string account; - nano::dev_genesis_key.pub.encode_account (account); + nano::dev::genesis_key.pub.encode_account (account); account[0] ^= 0x1; boost::property_tree::ptree request; request.put ("action", "validate_account_number"); request.put ("account", account); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string exists_text (response.json.get ("valid")); + auto response (wait_response (system, rpc, request)); + std::string exists_text (response.get ("valid")); ASSERT_EQ ("0", exists_text); } @@ -424,95 +398,68 @@ TEST (rpc, send) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "send"); - request.put ("source", nano::dev_genesis_key.pub.to_account ()); - request.put ("destination", nano::dev_genesis_key.pub.to_account ()); + request.put ("source", nano::dev::genesis_key.pub.to_account ()); + request.put ("destination", nano::dev::genesis_key.pub.to_account ()); request.put ("amount", "100"); - ASSERT_EQ (node->balance (nano::dev_genesis_key.pub), nano::genesis_amount); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string block_text (response.json.get ("block")); + ASSERT_EQ (node->balance (nano::dev::genesis_key.pub), nano::dev::constants.genesis_amount); + auto response (wait_response (system, rpc, request, 10s)); + std::string block_text (response.get ("block")); nano::block_hash block; ASSERT_FALSE (block.decode_hex (block_text)); ASSERT_TRUE (node->ledger.block_or_pruned_exists (block)); - ASSERT_EQ (node->latest (nano::dev_genesis_key.pub), block); - ASSERT_NE (node->balance (nano::dev_genesis_key.pub), nano::genesis_amount); + ASSERT_EQ (node->latest (nano::dev::genesis_key.pub), block); + ASSERT_NE (node->balance (nano::dev::genesis_key.pub), nano::dev::constants.genesis_amount); } TEST (rpc, send_fail) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "send"); - request.put ("source", nano::dev_genesis_key.pub.to_account ()); - request.put ("destination", nano::dev_genesis_key.pub.to_account ()); + request.put ("source", nano::dev::genesis_key.pub.to_account ()); + request.put ("destination", nano::dev::genesis_key.pub.to_account ()); request.put ("amount", "100"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (std::error_code (nano::error_common::account_not_found_wallet).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request, 10s)); + ASSERT_EQ (std::error_code (nano::error_common::account_not_found_wallet).message (), response.get ("error")); } TEST (rpc, send_work) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "send"); - request.put ("source", nano::dev_genesis_key.pub.to_account ()); - request.put ("destination", nano::dev_genesis_key.pub.to_account ()); + request.put ("source", nano::dev::genesis_key.pub.to_account ()); + request.put ("destination", nano::dev::genesis_key.pub.to_account ()); request.put ("amount", "100"); request.put ("work", "1"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (std::error_code (nano::error_common::invalid_work).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request, 10s)); + ASSERT_EQ (std::error_code (nano::error_common::invalid_work).message (), response.get ("error")); request.erase ("work"); - request.put ("work", nano::to_string_hex (*node->work_generate_blocking (node->latest (nano::dev_genesis_key.pub)))); - test_response response2 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response2.status != 0); - ASSERT_EQ (200, response2.status); - std::string block_text (response2.json.get ("block")); + request.put ("work", nano::to_string_hex (*node->work_generate_blocking (node->latest (nano::dev::genesis_key.pub)))); + auto response2 (wait_response (system, rpc, request, 10s)); + std::string block_text (response2.get ("block")); nano::block_hash block; ASSERT_FALSE (block.decode_hex (block_text)); ASSERT_TRUE (node->ledger.block_or_pruned_exists (block)); - ASSERT_EQ (node->latest (nano::dev_genesis_key.pub), block); + ASSERT_EQ (node->latest (nano::dev::genesis_key.pub), block); } TEST (rpc, send_work_disabled) @@ -520,118 +467,89 @@ TEST (rpc, send_work_disabled) nano::system system; nano::node_config node_config (nano::get_available_port (), system.logging); node_config.work_threads = 0; - auto & node = *add_ipc_enabled_node (system, node_config); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node = add_ipc_enabled_node (system, node_config); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; - node.wallets.items.begin ()->first.encode_hex (wallet); + node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "send"); - request.put ("source", nano::dev_genesis_key.pub.to_account ()); - request.put ("destination", nano::dev_genesis_key.pub.to_account ()); + request.put ("source", nano::dev::genesis_key.pub.to_account ()); + request.put ("destination", nano::dev::genesis_key.pub.to_account ()); request.put ("amount", "100"); - { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_common::disabled_work_generation).message (), response.json.get ("error")); - } + auto response (wait_response (system, rpc, request, 10s)); + ASSERT_EQ (std::error_code (nano::error_common::disabled_work_generation).message (), response.get ("error")); } TEST (rpc, send_idempotent) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "send"); - request.put ("source", nano::dev_genesis_key.pub.to_account ()); - request.put ("destination", nano::account (0).to_account ()); - request.put ("amount", (nano::genesis_amount - (nano::genesis_amount / 4)).convert_to ()); + request.put ("source", nano::dev::genesis_key.pub.to_account ()); + request.put ("destination", nano::account{}.to_account ()); + request.put ("amount", (nano::dev::constants.genesis_amount - (nano::dev::constants.genesis_amount / 4)).convert_to ()); request.put ("id", "123abc"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string block_text (response.json.get ("block")); + auto response (wait_response (system, rpc, request)); + std::string block_text (response.get ("block")); nano::block_hash block; ASSERT_FALSE (block.decode_hex (block_text)); ASSERT_TRUE (node->ledger.block_or_pruned_exists (block)); - ASSERT_EQ (node->balance (nano::dev_genesis_key.pub), nano::genesis_amount / 4); - test_response response2 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response2.status != 0); - ASSERT_EQ (200, response2.status); - ASSERT_EQ ("", response2.json.get ("error", "")); - ASSERT_EQ (block_text, response2.json.get ("block")); - ASSERT_EQ (node->balance (nano::dev_genesis_key.pub), nano::genesis_amount / 4); + ASSERT_EQ (node->balance (nano::dev::genesis_key.pub), nano::dev::constants.genesis_amount / 4); + auto response2 (wait_response (system, rpc, request)); + ASSERT_EQ ("", response2.get ("error", "")); + ASSERT_EQ (block_text, response2.get ("block")); + ASSERT_EQ (node->balance (nano::dev::genesis_key.pub), nano::dev::constants.genesis_amount / 4); request.erase ("id"); request.put ("id", "456def"); - test_response response3 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response3.status != 0); - ASSERT_EQ (200, response3.status); - ASSERT_EQ (std::error_code (nano::error_common::insufficient_balance).message (), response3.json.get ("error")); + auto response3 (wait_response (system, rpc, request)); + ASSERT_EQ (std::error_code (nano::error_common::insufficient_balance).message (), response3.get ("error")); } -TEST (rpc, send_epoch_2) +// Test disabled because it's failing intermittently. +// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3560 +// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3561 +// CI run in which it failed: https://github.com/nanocurrency/nano-node/runs/4280938039?check_suite_focus=true#step:5:1895 +TEST (rpc, DISABLED_send_epoch_2) { nano::system system; - auto & node = *add_ipc_enabled_node (system); + auto node = add_ipc_enabled_node (system); // Upgrade the genesis account to epoch 2 - ASSERT_NE (nullptr, system.upgrade_genesis_epoch (node, nano::epoch::epoch_1)); - ASSERT_NE (nullptr, system.upgrade_genesis_epoch (node, nano::epoch::epoch_2)); + ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_1)); + ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_2)); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv, false); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv, false); - auto target_difficulty = nano::work_threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, true, false, false)); - ASSERT_LT (node.network_params.network.publish_thresholds.entry, target_difficulty); - auto min_difficulty = node.network_params.network.publish_thresholds.entry; + auto target_difficulty = nano::dev::network_params.work.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, true, false, false)); + ASSERT_LT (node->network_params.work.entry, target_difficulty); + auto min_difficulty = node->network_params.work.entry; - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; - node.wallets.items.begin ()->first.encode_hex (wallet); + node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "send"); - request.put ("source", nano::dev_genesis_key.pub.to_account ()); + request.put ("source", nano::dev::genesis_key.pub.to_account ()); request.put ("destination", nano::keypair ().pub.to_account ()); request.put ("amount", "1"); // Test that the correct error is given if there is insufficient work - auto insufficient = system.work_generate_limited (nano::genesis_hash, min_difficulty, target_difficulty); + auto insufficient = system.work_generate_limited (nano::dev::genesis->hash (), min_difficulty, target_difficulty); request.put ("work", nano::to_string_hex (insufficient)); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::error_code ec (nano::error_common::invalid_work); - ASSERT_EQ (1, response.json.count ("error")); - ASSERT_EQ (response.json.get ("error"), ec.message ()); + ASSERT_EQ (1, response.count ("error")); + ASSERT_EQ (response.get ("error"), ec.message ()); } } @@ -639,25 +557,17 @@ TEST (rpc, send_ipc_random_id) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; + auto [rpc, rpc_ctx] = add_rpc (system, node); std::atomic got_request{ false }; - node_rpc_config.set_request_callback ([&got_request] (boost::property_tree::ptree const & request_a) { + rpc_ctx->node_rpc_config->set_request_callback ([&got_request] (boost::property_tree::ptree const & request_a) { EXPECT_TRUE (request_a.count ("id")); got_request = true; }); - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); boost::property_tree::ptree request; request.put ("action", "send"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (1, response.json.count ("error")); - ASSERT_EQ ("Unable to parse JSON", response.json.get ("error")); + auto response (wait_response (system, rpc, request, 10s)); + ASSERT_EQ (1, response.count ("error")); + ASSERT_EQ ("Unable to parse JSON", response.get ("error")); ASSERT_TRUE (got_request); } @@ -665,33 +575,17 @@ TEST (rpc, stop) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "stop"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ; + auto response (wait_response (system, rpc, request)); } TEST (rpc, wallet_add) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); nano::keypair key1; std::string key_text; key1.prv.encode_hex (key_text); @@ -701,10 +595,8 @@ TEST (rpc, wallet_add) request.put ("wallet", wallet); request.put ("action", "wallet_add"); request.put ("key", key_text); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string account_text1 (response.json.get ("account")); + auto response (wait_response (system, rpc, request)); + std::string account_text1 (response.get ("account")); ASSERT_EQ (account_text1, key1.pub.to_account ()); ASSERT_TRUE (system.wallet (0)->exists (key1.pub)); } @@ -713,23 +605,14 @@ TEST (rpc, wallet_password_valid) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "password_valid"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string account_text1 (response.json.get ("valid")); + auto response (wait_response (system, rpc, request)); + std::string account_text1 (response.get ("valid")); ASSERT_EQ (account_text1, "1"); } @@ -737,26 +620,17 @@ TEST (rpc, wallet_password_change) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "password_change"); request.put ("password", "test"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string account_text1 (response.json.get ("changed")); + auto response (wait_response (system, rpc, request)); + std::string account_text1 (response.get ("changed")); ASSERT_EQ (account_text1, "1"); - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); auto transaction (system.wallet (0)->wallets.tx_begin_write ()); ASSERT_TRUE (system.wallet (0)->store.valid_password (transaction)); ASSERT_TRUE (system.wallet (0)->enter_password (transaction, "")); @@ -769,7 +643,7 @@ TEST (rpc, wallet_password_enter) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; + auto [rpc, rpc_ctx] = add_rpc (system, node); nano::raw_key password_l; password_l.clear (); system.deadline_set (10s); @@ -778,23 +652,14 @@ TEST (rpc, wallet_password_enter) ASSERT_NO_ERROR (system.poll ()); system.wallet (0)->store.password.value (password_l); } - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "password_enter"); request.put ("password", ""); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string account_text1 (response.json.get ("valid")); + auto response (wait_response (system, rpc, request)); + std::string account_text1 (response.get ("valid")); ASSERT_EQ (account_text1, "1"); } @@ -802,38 +667,22 @@ TEST (rpc, wallet_representative) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "wallet_representative"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string account_text1 (response.json.get ("representative")); - ASSERT_EQ (account_text1, nano::genesis_account.to_account ()); + auto response (wait_response (system, rpc, request)); + std::string account_text1 (response.get ("representative")); + ASSERT_EQ (account_text1, nano::dev::genesis->account ().to_account ()); } TEST (rpc, wallet_representative_set) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); @@ -841,9 +690,7 @@ TEST (rpc, wallet_representative_set) nano::keypair key; request.put ("action", "wallet_representative_set"); request.put ("representative", key.pub.to_account ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); auto transaction (node->wallets.tx_begin_read ()); ASSERT_EQ (key.pub, node->wallets.items.begin ()->second->store.representative (transaction)); } @@ -852,15 +699,8 @@ TEST (rpc, wallet_representative_set_force) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); @@ -869,19 +709,17 @@ TEST (rpc, wallet_representative_set_force) request.put ("action", "wallet_representative_set"); request.put ("representative", key.pub.to_account ()); request.put ("update_existing_accounts", true); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); { auto transaction (node->wallets.tx_begin_read ()); ASSERT_EQ (key.pub, node->wallets.items.begin ()->second->store.representative (transaction)); } - nano::account representative (0); + nano::account representative{}; while (representative != key.pub) { auto transaction (node->store.tx_begin_read ()); nano::account_info info; - if (!node->store.account_get (transaction, nano::dev_genesis_key.pub, info)) + if (!node->store.account.get (transaction, nano::dev::genesis_key.pub, info)) { representative = info.representative; } @@ -894,25 +732,16 @@ TEST (rpc, account_list) nano::system system; auto node = add_ipc_enabled_node (system); nano::keypair key2; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key2.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "account_list"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & accounts_node (response.json.get_child ("accounts")); + auto response (wait_response (system, rpc, request)); + auto & accounts_node (response.get_child ("accounts")); std::vector accounts; for (auto i (accounts_node.begin ()), j (accounts_node.end ()); i != j; ++i) { @@ -932,24 +761,15 @@ TEST (rpc, wallet_key_valid) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "wallet_key_valid"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string exists_text (response.json.get ("valid")); + auto response (wait_response (system, rpc, request)); + std::string exists_text (response.get ("valid")); ASSERT_EQ ("1", exists_text); } @@ -957,20 +777,11 @@ TEST (rpc, wallet_create) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "wallet_create"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string wallet_text (response.json.get ("wallet")); + auto response (wait_response (system, rpc, request)); + std::string wallet_text (response.get ("wallet")); nano::wallet_id wallet_id; ASSERT_FALSE (wallet_id.decode_hex (wallet_text)); ASSERT_NE (node->wallets.items.end (), node->wallets.items.find (wallet_id)); @@ -980,25 +791,16 @@ TEST (rpc, wallet_create_seed) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; nano::raw_key seed; nano::random_pool::generate_block (seed.bytes.data (), seed.bytes.size ()); auto prv = nano::deterministic_key (seed, 0); auto pub (nano::pub_key (prv)); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "wallet_create"); request.put ("seed", seed.to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string wallet_text (response.json.get ("wallet")); + auto response (wait_response (system, rpc, request, 10s)); + std::string wallet_text (response.get ("wallet")); nano::wallet_id wallet_id; ASSERT_FALSE (wallet_id.decode_hex (wallet_text)); auto existing (node->wallets.items.find (wallet_id)); @@ -1009,63 +811,45 @@ TEST (rpc, wallet_create_seed) existing->second->store.seed (seed0, transaction); ASSERT_EQ (seed, seed0); } - auto account_text (response.json.get ("last_restored_account")); + auto account_text (response.get ("last_restored_account")); nano::account account; ASSERT_FALSE (account.decode_account (account_text)); ASSERT_TRUE (existing->second->exists (account)); ASSERT_EQ (pub, account); - ASSERT_EQ ("1", response.json.get ("restored_count")); + ASSERT_EQ ("1", response.get ("restored_count")); } TEST (rpc, wallet_export) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "wallet_export"); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string wallet_json (response.json.get ("json")); + auto response (wait_response (system, rpc, request)); + std::string wallet_json (response.get ("json")); bool error (false); - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); auto transaction (node->wallets.tx_begin_write ()); - nano::kdf kdf; - nano::wallet_store store (error, kdf, transaction, nano::genesis_account, 1, "0", wallet_json); + nano::kdf kdf{ nano::dev::network_params.kdf_work }; + nano::wallet_store store (error, kdf, transaction, nano::dev::genesis->account (), 1, "0", wallet_json); ASSERT_FALSE (error); - ASSERT_TRUE (store.exists (transaction, nano::dev_genesis_key.pub)); + ASSERT_TRUE (store.exists (transaction, nano::dev::genesis_key.pub)); } TEST (rpc, wallet_destroy) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); auto wallet_id (node->wallets.items.begin ()->first); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); boost::property_tree::ptree request; request.put ("action", "wallet_destroy"); request.put ("wallet", wallet_id.to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); ASSERT_EQ (node->wallets.items.end (), node->wallets.items.find (wallet_id)); } @@ -1075,19 +859,12 @@ TEST (rpc, account_move) auto node = add_ipc_enabled_node (system); auto wallet_id (node->wallets.items.begin ()->first); auto destination (system.wallet (0)); - destination->insert_adhoc (nano::dev_genesis_key.prv); + destination->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key; auto source_id = nano::random_wallet_id (); auto source (node->wallets.create (source_id)); source->insert_adhoc (key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "account_move"); request.put ("wallet", wallet_id.to_string ()); @@ -1097,12 +874,10 @@ TEST (rpc, account_move) entry.put ("", key.pub.to_account ()); keys.push_back (std::make_pair ("", entry)); request.add_child ("accounts", keys); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ ("1", response.json.get ("moved")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ ("1", response.get ("moved")); ASSERT_TRUE (destination->exists (key.pub)); - ASSERT_TRUE (destination->exists (nano::dev_genesis_key.pub)); + ASSERT_TRUE (destination->exists (nano::dev::genesis_key.pub)); auto transaction (node->wallets.tx_begin_read ()); ASSERT_EQ (source->store.end (), source->store.begin (transaction)); } @@ -1111,45 +886,26 @@ TEST (rpc, block) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block"); - request.put ("hash", node->latest (nano::genesis_account).to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto contents (response.json.get ("contents")); + request.put ("hash", node->latest (nano::dev::genesis->account ()).to_string ()); + auto response (wait_response (system, rpc, request)); + auto contents (response.get ("contents")); ASSERT_FALSE (contents.empty ()); - ASSERT_TRUE (response.json.get ("confirmed")); // Genesis block is confirmed by default + ASSERT_TRUE (response.get ("confirmed")); // Genesis block is confirmed by default } TEST (rpc, block_account) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); - nano::genesis genesis; + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block_account"); - request.put ("hash", genesis.hash ().to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string account_text (response.json.get ("account")); + request.put ("hash", nano::dev::genesis->hash ().to_string ()); + auto response (wait_response (system, rpc, request)); + std::string account_text (response.get ("account")); nano::account account; ASSERT_FALSE (account.decode_account (account_text)); } @@ -1158,28 +914,19 @@ TEST (rpc, chain) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key; - auto genesis (node->latest (nano::dev_genesis_key.pub)); + auto genesis (node->latest (nano::dev::genesis_key.pub)); ASSERT_FALSE (genesis.is_zero ()); - auto block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 1)); + auto block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 1)); ASSERT_NE (nullptr, block); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "chain"); request.put ("block", block->hash ().to_string ()); request.put ("count", std::to_string (std::numeric_limits::max ())); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & blocks_node (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + auto & blocks_node (response.get_child ("blocks")); std::vector blocks; for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i) { @@ -1194,28 +941,19 @@ TEST (rpc, chain_limit) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key; - auto genesis (node->latest (nano::dev_genesis_key.pub)); + auto genesis (node->latest (nano::dev::genesis_key.pub)); ASSERT_FALSE (genesis.is_zero ()); - auto block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 1)); + auto block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 1)); ASSERT_NE (nullptr, block); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "chain"); request.put ("block", block->hash ().to_string ()); request.put ("count", 1); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & blocks_node (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + auto & blocks_node (response.get_child ("blocks")); std::vector blocks; for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i) { @@ -1229,29 +967,20 @@ TEST (rpc, chain_offset) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key; - auto genesis (node->latest (nano::dev_genesis_key.pub)); + auto genesis (node->latest (nano::dev::genesis_key.pub)); ASSERT_FALSE (genesis.is_zero ()); - auto block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 1)); + auto block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 1)); ASSERT_NE (nullptr, block); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "chain"); request.put ("block", block->hash ().to_string ()); request.put ("count", std::to_string (std::numeric_limits::max ())); request.put ("offset", 1); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & blocks_node (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + auto & blocks_node (response.get_child ("blocks")); std::vector blocks; for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i) { @@ -1274,27 +1003,18 @@ TEST (rpc, frontier) nano::block_hash hash; nano::random_pool::generate_block (hash.bytes.data (), hash.bytes.size ()); source[key.pub] = hash; - node->store.confirmation_height_put (transaction, key.pub, { 0, nano::block_hash (0) }); - node->store.account_put (transaction, key.pub, nano::account_info (hash, 0, 0, 0, 0, 0, nano::epoch::epoch_0)); + node->store.confirmation_height.put (transaction, key.pub, { 0, nano::block_hash (0) }); + node->store.account.put (transaction, key.pub, nano::account_info (hash, 0, 0, 0, 0, 0, nano::epoch::epoch_0)); } } - scoped_io_thread_name_change scoped_thread_name_io; nano::keypair key; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "frontiers"); - request.put ("account", nano::account (0).to_account ()); + request.put ("account", nano::account{}.to_account ()); request.put ("count", std::to_string (std::numeric_limits::max ())); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & frontiers_node (response.json.get_child ("frontiers")); + auto response (wait_response (system, rpc, request)); + auto & frontiers_node (response.get_child ("frontiers")); std::unordered_map frontiers; for (auto i (frontiers_node.begin ()), j (frontiers_node.end ()); i != j; ++i) { @@ -1304,7 +1024,7 @@ TEST (rpc, frontier) frontier.decode_hex (i->second.get ("")); frontiers[account] = frontier; } - ASSERT_EQ (1, frontiers.erase (nano::dev_genesis_key.pub)); + ASSERT_EQ (1, frontiers.erase (nano::dev::genesis_key.pub)); ASSERT_EQ (source, frontiers); } @@ -1321,28 +1041,18 @@ TEST (rpc, frontier_limited) nano::block_hash hash; nano::random_pool::generate_block (hash.bytes.data (), hash.bytes.size ()); source[key.pub] = hash; - node->store.confirmation_height_put (transaction, key.pub, { 0, nano::block_hash (0) }); - node->store.account_put (transaction, key.pub, nano::account_info (hash, 0, 0, 0, 0, 0, nano::epoch::epoch_0)); + node->store.confirmation_height.put (transaction, key.pub, { 0, nano::block_hash (0) }); + node->store.account.put (transaction, key.pub, nano::account_info (hash, 0, 0, 0, 0, 0, nano::epoch::epoch_0)); } } - - scoped_io_thread_name_change scoped_thread_name_io; nano::keypair key; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "frontiers"); - request.put ("account", nano::account (0).to_account ()); + request.put ("account", nano::account{}.to_account ()); request.put ("count", std::to_string (100)); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & frontiers_node (response.json.get_child ("frontiers")); + auto response (wait_response (system, rpc, request)); + auto & frontiers_node (response.get_child ("frontiers")); ASSERT_EQ (100, frontiers_node.size ()); } @@ -1359,27 +1069,18 @@ TEST (rpc, frontier_startpoint) nano::block_hash hash; nano::random_pool::generate_block (hash.bytes.data (), hash.bytes.size ()); source[key.pub] = hash; - node->store.confirmation_height_put (transaction, key.pub, { 0, nano::block_hash (0) }); - node->store.account_put (transaction, key.pub, nano::account_info (hash, 0, 0, 0, 0, 0, nano::epoch::epoch_0)); + node->store.confirmation_height.put (transaction, key.pub, { 0, nano::block_hash (0) }); + node->store.account.put (transaction, key.pub, nano::account_info (hash, 0, 0, 0, 0, 0, nano::epoch::epoch_0)); } } - scoped_io_thread_name_change scoped_thread_name_io; nano::keypair key; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "frontiers"); request.put ("account", source.begin ()->first.to_account ()); request.put ("count", std::to_string (1)); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & frontiers_node (response.json.get_child ("frontiers")); + auto response (wait_response (system, rpc, request)); + auto & frontiers_node (response.get_child ("frontiers")); ASSERT_EQ (1, frontiers_node.size ()); ASSERT_EQ (source.begin ()->first.to_account (), frontiers_node.begin ()->first); } @@ -1388,40 +1089,30 @@ TEST (rpc, history) { nano::system system; auto node0 = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto change (system.wallet (0)->change_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto change (system.wallet (0)->change_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub)); ASSERT_NE (nullptr, change); - auto send (system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, node0->config.receive_minimum.number ())); + auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, node0->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); - auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev_genesis_key.pub, node0->config.receive_minimum.number (), send->link ().as_account ())); + auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node0->config.receive_minimum.number (), send->link ().as_account ())); ASSERT_NE (nullptr, receive); - nano::genesis genesis; - nano::state_block usend (nano::genesis_account, node0->latest (nano::genesis_account), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (node0->latest (nano::genesis_account))); - nano::state_block ureceive (nano::genesis_account, usend.hash (), nano::genesis_account, nano::genesis_amount, usend.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (usend.hash ())); - nano::state_block uchange (nano::genesis_account, ureceive.hash (), nano::keypair ().pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (ureceive.hash ())); + nano::state_block usend (nano::dev::genesis->account (), node0->latest (nano::dev::genesis->account ()), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (node0->latest (nano::dev::genesis->account ()))); + nano::state_block ureceive (nano::dev::genesis->account (), usend.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, usend.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (usend.hash ())); + nano::state_block uchange (nano::dev::genesis->account (), ureceive.hash (), nano::keypair ().pub, nano::dev::constants.genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (ureceive.hash ())); { auto transaction (node0->store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, usend).code); ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, ureceive).code); ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, uchange).code); } - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node0, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node0->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node0); boost::property_tree::ptree request; request.put ("action", "history"); request.put ("hash", uchange.hash ().to_string ()); request.put ("count", 100); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::vector> history_l; - auto & history_node (response.json.get_child ("history")); + auto & history_node (response.get_child ("history")); for (auto i (history_node.begin ()), n (history_node.end ()); i != n; ++i) { history_l.push_back (std::make_tuple (i->second.get ("type"), i->second.get ("account"), i->second.get ("amount"), i->second.get ("hash"))); @@ -1429,136 +1120,128 @@ TEST (rpc, history) ASSERT_EQ (5, history_l.size ()); ASSERT_EQ ("receive", std::get<0> (history_l[0])); ASSERT_EQ (ureceive.hash ().to_string (), std::get<3> (history_l[0])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[0])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[0])); ASSERT_EQ (nano::MBAN_ratio.convert_to (), std::get<2> (history_l[0])); ASSERT_EQ (5, history_l.size ()); ASSERT_EQ ("send", std::get<0> (history_l[1])); ASSERT_EQ (usend.hash ().to_string (), std::get<3> (history_l[1])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[1])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[1])); ASSERT_EQ (nano::MBAN_ratio.convert_to (), std::get<2> (history_l[1])); ASSERT_EQ ("receive", std::get<0> (history_l[2])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[2])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[2])); ASSERT_EQ (node0->config.receive_minimum.to_string_dec (), std::get<2> (history_l[2])); ASSERT_EQ (receive->hash ().to_string (), std::get<3> (history_l[2])); ASSERT_EQ ("send", std::get<0> (history_l[3])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[3])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[3])); ASSERT_EQ (node0->config.receive_minimum.to_string_dec (), std::get<2> (history_l[3])); ASSERT_EQ (send->hash ().to_string (), std::get<3> (history_l[3])); ASSERT_EQ ("receive", std::get<0> (history_l[4])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[4])); - ASSERT_EQ (nano::genesis_amount.convert_to (), std::get<2> (history_l[4])); - ASSERT_EQ (genesis.hash ().to_string (), std::get<3> (history_l[4])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[4])); + ASSERT_EQ (nano::dev::constants.genesis_amount.convert_to (), std::get<2> (history_l[4])); + ASSERT_EQ (nano::dev::genesis->hash ().to_string (), std::get<3> (history_l[4])); } TEST (rpc, account_history) { nano::system system; auto node0 = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto change (system.wallet (0)->change_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto change (system.wallet (0)->change_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub)); ASSERT_NE (nullptr, change); - auto send (system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, node0->config.receive_minimum.number ())); + auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, node0->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); - auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev_genesis_key.pub, node0->config.receive_minimum.number (), send->link ().as_account ())); + auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node0->config.receive_minimum.number (), send->link ().as_account ())); ASSERT_NE (nullptr, receive); - nano::genesis genesis; - nano::state_block usend (nano::genesis_account, node0->latest (nano::genesis_account), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (node0->latest (nano::genesis_account))); - nano::state_block ureceive (nano::genesis_account, usend.hash (), nano::genesis_account, nano::genesis_amount, usend.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (usend.hash ())); - nano::state_block uchange (nano::genesis_account, ureceive.hash (), nano::keypair ().pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (ureceive.hash ())); + nano::state_block usend (nano::dev::genesis->account (), node0->latest (nano::dev::genesis->account ()), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (node0->latest (nano::dev::genesis->account ()))); + nano::state_block ureceive (nano::dev::genesis->account (), usend.hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, usend.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (usend.hash ())); + nano::state_block uchange (nano::dev::genesis->account (), ureceive.hash (), nano::keypair ().pub, nano::dev::constants.genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (ureceive.hash ())); { auto transaction (node0->store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, usend).code); ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, ureceive).code); ASSERT_EQ (nano::process_result::progress, node0->ledger.process (transaction, uchange).code); } - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node0, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node0->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node0); { boost::property_tree::ptree request; request.put ("action", "account_history"); - request.put ("account", nano::genesis_account.to_account ()); + request.put ("account", nano::dev::genesis->account ().to_account ()); request.put ("count", 100); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - std::vector> history_l; - auto & history_node (response.json.get_child ("history")); + auto response (wait_response (system, rpc, request, 10s)); + std::vector> history_l; + auto & history_node (response.get_child ("history")); for (auto i (history_node.begin ()), n (history_node.end ()); i != n; ++i) { - history_l.push_back (std::make_tuple (i->second.get ("type"), i->second.get ("account"), i->second.get ("amount"), i->second.get ("hash"), i->second.get ("height"))); + history_l.push_back (std::make_tuple (i->second.get ("type"), i->second.get ("account"), i->second.get ("amount"), i->second.get ("hash"), i->second.get ("height"), i->second.get ("confirmed"))); } ASSERT_EQ (5, history_l.size ()); ASSERT_EQ ("receive", std::get<0> (history_l[0])); ASSERT_EQ (ureceive.hash ().to_string (), std::get<3> (history_l[0])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[0])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[0])); ASSERT_EQ (nano::MBAN_ratio.convert_to (), std::get<2> (history_l[0])); ASSERT_EQ ("6", std::get<4> (history_l[0])); // change block (height 7) is skipped by account_history since "raw" is not set + ASSERT_FALSE (std::get<5> (history_l[0])); ASSERT_EQ ("send", std::get<0> (history_l[1])); ASSERT_EQ (usend.hash ().to_string (), std::get<3> (history_l[1])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[1])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[1])); ASSERT_EQ (nano::MBAN_ratio.convert_to (), std::get<2> (history_l[1])); ASSERT_EQ ("5", std::get<4> (history_l[1])); + ASSERT_FALSE (std::get<5> (history_l[1])); ASSERT_EQ ("receive", std::get<0> (history_l[2])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[2])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[2])); ASSERT_EQ (node0->config.receive_minimum.to_string_dec (), std::get<2> (history_l[2])); ASSERT_EQ (receive->hash ().to_string (), std::get<3> (history_l[2])); ASSERT_EQ ("4", std::get<4> (history_l[2])); + ASSERT_FALSE (std::get<5> (history_l[2])); ASSERT_EQ ("send", std::get<0> (history_l[3])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[3])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[3])); ASSERT_EQ (node0->config.receive_minimum.to_string_dec (), std::get<2> (history_l[3])); ASSERT_EQ (send->hash ().to_string (), std::get<3> (history_l[3])); ASSERT_EQ ("3", std::get<4> (history_l[3])); + ASSERT_FALSE (std::get<5> (history_l[3])); ASSERT_EQ ("receive", std::get<0> (history_l[4])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[4])); - ASSERT_EQ (nano::genesis_amount.convert_to (), std::get<2> (history_l[4])); - ASSERT_EQ (genesis.hash ().to_string (), std::get<3> (history_l[4])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[4])); + ASSERT_EQ (nano::dev::constants.genesis_amount.convert_to (), std::get<2> (history_l[4])); + ASSERT_EQ (nano::dev::genesis->hash ().to_string (), std::get<3> (history_l[4])); ASSERT_EQ ("1", std::get<4> (history_l[4])); // change block (height 2) is skipped + ASSERT_TRUE (std::get<5> (history_l[4])); } // Test count and reverse { boost::property_tree::ptree request; request.put ("action", "account_history"); - request.put ("account", nano::genesis_account.to_account ()); + request.put ("account", nano::dev::genesis->account ().to_account ()); request.put ("reverse", true); request.put ("count", 1); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & history_node (response.json.get_child ("history")); + auto response (wait_response (system, rpc, request, 10s)); + auto & history_node (response.get_child ("history")); ASSERT_EQ (1, history_node.size ()); ASSERT_EQ ("1", history_node.begin ()->second.get ("height")); - ASSERT_EQ (change->hash ().to_string (), response.json.get ("next")); + ASSERT_EQ (change->hash ().to_string (), response.get ("next")); } // Test filtering - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); auto account2 (system.wallet (0)->deterministic_insert ()); - auto send2 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, account2, node0->config.receive_minimum.number ())); + auto send2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, account2, node0->config.receive_minimum.number ())); ASSERT_NE (nullptr, send2); auto receive2 (system.wallet (0)->receive_action (send2->hash (), account2, node0->config.receive_minimum.number (), send2->link ().as_account ())); - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->renew (); // Test filter for send state blocks ASSERT_NE (nullptr, receive2); { boost::property_tree::ptree request; request.put ("action", "account_history"); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); boost::property_tree::ptree other_account; other_account.put ("", account2.to_account ()); boost::property_tree::ptree filtered_accounts; filtered_accounts.push_back (std::make_pair ("", other_account)); request.add_child ("account_filter", filtered_accounts); request.put ("count", 100); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - auto history_node (response.json.get_child ("history")); + auto response (wait_response (system, rpc, request)); + auto history_node (response.get_child ("history")); ASSERT_EQ (history_node.size (), 2); } // Test filter for receive state blocks @@ -1567,14 +1250,13 @@ TEST (rpc, account_history) request.put ("action", "account_history"); request.put ("account", account2.to_account ()); boost::property_tree::ptree other_account; - other_account.put ("", nano::dev_genesis_key.pub.to_account ()); + other_account.put ("", nano::dev::genesis_key.pub.to_account ()); boost::property_tree::ptree filtered_accounts; filtered_accounts.push_back (std::make_pair ("", other_account)); request.add_child ("account_filter", filtered_accounts); request.put ("count", 100); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - auto history_node (response.json.get_child ("history")); + auto response (wait_response (system, rpc, request)); + auto history_node (response.get_child ("history")); ASSERT_EQ (history_node.size (), 1); } } @@ -1583,29 +1265,20 @@ TEST (rpc, history_count) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto change (system.wallet (0)->change_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto change (system.wallet (0)->change_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub)); ASSERT_NE (nullptr, change); - auto send (system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, node->config.receive_minimum.number ())); + auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, node->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); - auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev_genesis_key.pub, node->config.receive_minimum.number (), send->link ().as_account ())); + auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node->config.receive_minimum.number (), send->link ().as_account ())); ASSERT_NE (nullptr, receive); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "history"); request.put ("hash", receive->hash ().to_string ()); request.put ("count", 1); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & history_node (response.json.get_child ("history")); + auto response (wait_response (system, rpc, request)); + auto & history_node (response.get_child ("history")); ASSERT_EQ (1, history_node.size ()); } @@ -1617,21 +1290,20 @@ TEST (rpc, history_pruning) nano::node_flags node_flags; node_flags.enable_pruning = true; auto node0 = add_ipc_enabled_node (system, node_config, node_flags); - nano::genesis genesis; - auto change (std::make_shared (genesis.hash (), nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work.generate (genesis.hash ()))); + auto change (std::make_shared (nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work.generate (nano::dev::genesis->hash ()))); node0->process_active (change); - auto send (std::make_shared (change->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - node0->config.receive_minimum.number (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work.generate (change->hash ()))); + auto send (std::make_shared (change->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - node0->config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work.generate (change->hash ()))); node0->process_active (send); - auto receive (std::make_shared (send->hash (), send->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work.generate (send->hash ()))); + auto receive (std::make_shared (send->hash (), send->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work.generate (send->hash ()))); node0->process_active (receive); - auto usend (std::make_shared (nano::genesis_account, receive->hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::genesis_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (receive->hash ()))); - auto ureceive (std::make_shared (nano::genesis_account, usend->hash (), nano::genesis_account, nano::genesis_amount, usend->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (usend->hash ()))); - auto uchange (std::make_shared (nano::genesis_account, ureceive->hash (), nano::keypair ().pub, nano::genesis_amount, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node0->work_generate_blocking (ureceive->hash ()))); + auto usend (std::make_shared (nano::dev::genesis->account (), receive->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis->account (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (receive->hash ()))); + auto ureceive (std::make_shared (nano::dev::genesis->account (), usend->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount, usend->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (usend->hash ()))); + auto uchange (std::make_shared (nano::dev::genesis->account (), ureceive->hash (), nano::keypair ().pub, nano::dev::constants.genesis_amount, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node0->work_generate_blocking (ureceive->hash ()))); node0->process_active (usend); node0->process_active (ureceive); node0->process_active (uchange); node0->block_processor.flush (); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // Confirm last block to prune previous { auto election = node0->active.election (change->qualified_root ()); @@ -1675,22 +1347,14 @@ TEST (rpc, history_pruning) auto transaction (node0->store.tx_begin_write ()); ASSERT_EQ (1, node0->ledger.pruning_action (transaction, change->hash (), 1)); } - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node0, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node0->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node0); boost::property_tree::ptree request; request.put ("action", "history"); request.put ("hash", send->hash ().to_string ()); request.put ("count", 100); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::vector> history_l; - auto & history_node (response.json.get_child ("history")); + auto & history_node (response.get_child ("history")); for (auto i (history_node.begin ()), n (history_node.end ()); i != n; ++i) { history_l.push_back (std::make_tuple (i->second.get ("type"), i->second.get ("account", "-1"), i->second.get ("amount", "-1"), i->second.get ("hash"))); @@ -1699,23 +1363,23 @@ TEST (rpc, history_pruning) } ASSERT_EQ (1, history_l.size ()); ASSERT_EQ ("send", std::get<0> (history_l[0])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[0])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[0])); ASSERT_EQ ("-1", std::get<2> (history_l[0])); ASSERT_EQ (send->hash ().to_string (), std::get<3> (history_l[0])); // Pruning action { + rpc_ctx->io_scope->reset (); auto transaction (node0->store.tx_begin_write ()); ASSERT_EQ (1, node0->ledger.pruning_action (transaction, send->hash (), 1)); + rpc_ctx->io_scope->renew (); } boost::property_tree::ptree request2; request2.put ("action", "history"); request2.put ("hash", receive->hash ().to_string ()); request2.put ("count", 100); - test_response response2 (request2, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response2.status != 0); - ASSERT_EQ (200, response2.status); + auto response2 (wait_response (system, rpc, request2)); history_l.clear (); - auto & history_node2 (response2.json.get_child ("history")); + auto & history_node2 (response2.get_child ("history")); for (auto i (history_node2.begin ()), n (history_node2.end ()); i != n; ++i) { history_l.push_back (std::make_tuple (i->second.get ("type"), i->second.get ("account", "-1"), i->second.get ("amount", "-1"), i->second.get ("hash"))); @@ -1731,18 +1395,18 @@ TEST (rpc, history_pruning) ASSERT_EQ (receive->hash ().to_string (), std::get<3> (history_l[0])); // Pruning action { + rpc_ctx->io_scope->reset (); auto transaction (node0->store.tx_begin_write ()); ASSERT_EQ (1, node0->ledger.pruning_action (transaction, receive->hash (), 1)); + rpc_ctx->io_scope->renew (); } boost::property_tree::ptree request3; request3.put ("action", "history"); request3.put ("hash", uchange->hash ().to_string ()); request3.put ("count", 100); - test_response response3 (request3, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response3.status != 0); - ASSERT_EQ (200, response3.status); + auto response3 (wait_response (system, rpc, request3)); history_l.clear (); - auto & history_node3 (response3.json.get_child ("history")); + auto & history_node3 (response3.get_child ("history")); for (auto i (history_node3.begin ()), n (history_node3.end ()); i != n; ++i) { history_l.push_back (std::make_tuple (i->second.get ("type"), i->second.get ("account", "-1"), i->second.get ("amount", "-1"), i->second.get ("hash"))); @@ -1750,7 +1414,7 @@ TEST (rpc, history_pruning) ASSERT_EQ (2, history_l.size ()); ASSERT_EQ ("receive", std::get<0> (history_l[0])); ASSERT_EQ (ureceive->hash ().to_string (), std::get<3> (history_l[0])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[0])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[0])); ASSERT_EQ (nano::MBAN_ratio.convert_to (), std::get<2> (history_l[0])); ASSERT_EQ ("unknown", std::get<0> (history_l[1])); ASSERT_EQ ("-1", std::get<1> (history_l[1])); @@ -1761,75 +1425,53 @@ TEST (rpc, history_pruning) TEST (rpc, process_block) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); nano::keypair key; - auto latest (node1.latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, key.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); boost::property_tree::ptree request; request.put ("action", "process"); std::string json; send.serialize_json (json); request.put ("block", json); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_TIMELY (10s, node1.latest (nano::dev_genesis_key.pub) == send.hash ()); - std::string send_hash (response.json.get ("hash")); + auto response (wait_response (system, rpc, request)); + ASSERT_TIMELY (10s, node1->latest (nano::dev::genesis_key.pub) == send.hash ()); + std::string send_hash (response.get ("hash")); ASSERT_EQ (send.hash ().to_string (), send_hash); } request.put ("json_block", true); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::error_code ec (nano::error_blocks::invalid_block); - ASSERT_EQ (ec.message (), response.json.get ("error")); + ASSERT_EQ (ec.message (), response.get ("error")); } } TEST (rpc, process_json_block) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); nano::keypair key; - auto latest (node1.latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, key.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); boost::property_tree::ptree request; request.put ("action", "process"); boost::property_tree::ptree block_node; send.serialize_json (block_node); request.add_child ("block", block_node); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::error_code ec (nano::error_blocks::invalid_block); - ASSERT_EQ (ec.message (), response.json.get ("error")); + ASSERT_EQ (ec.message (), response.get ("error")); } request.put ("json_block", true); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_TIMELY (10s, node1.latest (nano::dev_genesis_key.pub) == send.hash ()); - std::string send_hash (response.json.get ("hash")); + auto response (wait_response (system, rpc, request)); + ASSERT_TIMELY (10s, node1->latest (nano::dev::genesis_key.pub) == send.hash ()); + std::string send_hash (response.get ("hash")); ASSERT_EQ (send.hash ().to_string (), send_hash); } } @@ -1837,18 +1479,11 @@ TEST (rpc, process_json_block) TEST (rpc, process_block_async) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); nano::keypair key; - auto latest (node1.latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, key.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); boost::property_tree::ptree request; request.put ("action", "process"); request.put ("async", "true"); @@ -1857,59 +1492,44 @@ TEST (rpc, process_block_async) request.put ("block", json); request.put ("json_block", true); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::error_code ec (nano::error_blocks::invalid_block); - ASSERT_EQ (ec.message (), response.json.get ("error")); + ASSERT_EQ (ec.message (), response.get ("error")); } request.put ("json_block", false); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::error_code ec (nano::error_common::is_not_state_block); - ASSERT_EQ (ec.message (), response.json.get ("error")); + ASSERT_EQ (ec.message (), response.get ("error")); } - auto state_send (std::make_shared (nano::dev_genesis_key.pub, latest, nano::dev_genesis_key.pub, nano::genesis_amount - 100, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest))); + auto state_send (std::make_shared (nano::dev::genesis_key.pub, latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest))); std::string json1; state_send->serialize_json (json1); request.put ("block", json1); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ ("1", response.json.get ("started")); - ASSERT_TIMELY (10s, node1.latest (nano::dev_genesis_key.pub) == state_send->hash ()); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ ("1", response.get ("started")); + ASSERT_TIMELY (10s, node1->latest (nano::dev::genesis_key.pub) == state_send->hash ()); } } TEST (rpc, process_block_no_work) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); nano::keypair key; - auto latest (node1.latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, key.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); send.block_work_set (0); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); boost::property_tree::ptree request; request.put ("action", "process"); std::string json; send.serialize_json (json); request.put ("block", json); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_FALSE (response.json.get ("error", "").empty ()); + auto response (wait_response (system, rpc, request)); + ASSERT_FALSE (response.get ("error", "").empty ()); } TEST (rpc, process_republish) @@ -1917,188 +1537,131 @@ TEST (rpc, process_republish) nano::system system (2); auto & node1 (*system.nodes[0]); auto & node2 (*system.nodes[1]); - auto & node3 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; + auto node3 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node3); nano::keypair key; - auto latest (node1.latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, key.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node3.work_generate_blocking (latest)); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node3, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node3.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto latest (node1.latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node3->work_generate_blocking (latest)); boost::property_tree::ptree request; request.put ("action", "process"); std::string json; send.serialize_json (json); request.put ("block", json); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_TIMELY (10s, node2.latest (nano::dev_genesis_key.pub) == send.hash ()); + auto response (wait_response (system, rpc, request)); + ASSERT_TIMELY (10s, node2.latest (nano::dev::genesis_key.pub) == send.hash ()); } TEST (rpc, process_subtype_send) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); + auto node1 = add_ipc_enabled_node (system); system.add_node (); - scoped_io_thread_name_change scoped_thread_name_io; + auto [rpc, rpc_ctx] = add_rpc (system, node1); nano::keypair key; - auto latest (node1.latest (nano::dev_genesis_key.pub)); - nano::state_block send (nano::genesis_account, latest, nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::state_block send (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); boost::property_tree::ptree request; request.put ("action", "process"); std::string json; send.serialize_json (json); request.put ("block", json); request.put ("subtype", "receive"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::error_code ec (nano::error_rpc::invalid_subtype_balance); - ASSERT_EQ (response.json.get ("error"), ec.message ()); + ASSERT_EQ (response.get ("error"), ec.message ()); request.put ("subtype", "change"); - test_response response2 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response2.status != 0); - ASSERT_EQ (200, response2.status); - ASSERT_EQ (response2.json.get ("error"), ec.message ()); + auto response2 (wait_response (system, rpc, request)); + ASSERT_EQ (response2.get ("error"), ec.message ()); request.put ("subtype", "send"); - test_response response3 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response3.status != 0); - ASSERT_EQ (200, response3.status); - ASSERT_EQ (send.hash ().to_string (), response3.json.get ("hash")); - ASSERT_TIMELY (10s, system.nodes[1]->latest (nano::dev_genesis_key.pub) == send.hash ()); + auto response3 (wait_response (system, rpc, request)); + ASSERT_EQ (send.hash ().to_string (), response3.get ("hash")); + ASSERT_TIMELY (10s, system.nodes[1]->latest (nano::dev::genesis_key.pub) == send.hash ()); } TEST (rpc, process_subtype_open) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); + auto node1 = add_ipc_enabled_node (system); auto & node2 = *system.add_node (); nano::keypair key; - auto latest (node1.latest (nano::dev_genesis_key.pub)); - auto send = std::make_shared (nano::genesis_account, latest, nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - ASSERT_EQ (nano::process_result::progress, node1.process (*send).code); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + auto send = std::make_shared (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); ASSERT_EQ (nano::process_result::progress, node2.process (*send).code); - scoped_io_thread_name_change scoped_thread_name_io; - node1.scheduler.manual (send); - nano::state_block open (key.pub, 0, key.pub, nano::MBAN_ratio, send->hash (), key.prv, key.pub, *node1.work_generate_blocking (key.pub)); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node1); + node1->scheduler.manual (send); + nano::state_block open (key.pub, 0, key.pub, nano::MBAN_ratio, send->hash (), key.prv, key.pub, *node1->work_generate_blocking (key.pub)); boost::property_tree::ptree request; request.put ("action", "process"); std::string json; open.serialize_json (json); request.put ("block", json); request.put ("subtype", "send"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::error_code ec (nano::error_rpc::invalid_subtype_balance); - ASSERT_EQ (response.json.get ("error"), ec.message ()); + ASSERT_EQ (response.get ("error"), ec.message ()); request.put ("subtype", "epoch"); - test_response response2 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response2.status != 0); - ASSERT_EQ (200, response2.status); - ASSERT_EQ (response2.json.get ("error"), ec.message ()); + auto response2 (wait_response (system, rpc, request)); + ASSERT_EQ (response2.get ("error"), ec.message ()); request.put ("subtype", "open"); - test_response response3 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response3.status != 0); - ASSERT_EQ (200, response3.status); - ASSERT_EQ (open.hash ().to_string (), response3.json.get ("hash")); + auto response3 (wait_response (system, rpc, request)); + ASSERT_EQ (open.hash ().to_string (), response3.get ("hash")); ASSERT_TIMELY (10s, node2.latest (key.pub) == open.hash ()); } TEST (rpc, process_subtype_receive) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); + auto node1 = add_ipc_enabled_node (system); auto & node2 = *system.add_node (); - auto latest (node1.latest (nano::dev_genesis_key.pub)); - auto send = std::make_shared (nano::genesis_account, latest, nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - ASSERT_EQ (nano::process_result::progress, node1.process (*send).code); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + auto send = std::make_shared (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + ASSERT_EQ (nano::process_result::progress, node1->process (*send).code); ASSERT_EQ (nano::process_result::progress, node2.process (*send).code); - scoped_io_thread_name_change scoped_thread_name_io; - node1.scheduler.manual (send); - nano::state_block receive (nano::dev_genesis_key.pub, send->hash (), nano::dev_genesis_key.pub, nano::genesis_amount, send->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (send->hash ())); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node1); + node1->scheduler.manual (send); + nano::state_block receive (nano::dev::genesis_key.pub, send->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount, send->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (send->hash ())); boost::property_tree::ptree request; request.put ("action", "process"); std::string json; receive.serialize_json (json); request.put ("block", json); request.put ("subtype", "send"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::error_code ec (nano::error_rpc::invalid_subtype_balance); - ASSERT_EQ (response.json.get ("error"), ec.message ()); + ASSERT_EQ (response.get ("error"), ec.message ()); request.put ("subtype", "open"); - test_response response2 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response2.status != 0); - ASSERT_EQ (200, response2.status); + auto response2 (wait_response (system, rpc, request)); ec = nano::error_rpc::invalid_subtype_previous; - ASSERT_EQ (response2.json.get ("error"), ec.message ()); + ASSERT_EQ (response2.get ("error"), ec.message ()); request.put ("subtype", "receive"); - test_response response3 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response3.status != 0); - ASSERT_EQ (200, response3.status); - ASSERT_EQ (receive.hash ().to_string (), response3.json.get ("hash")); - ASSERT_TIMELY (10s, node2.latest (nano::dev_genesis_key.pub) == receive.hash ()); + auto response3 (wait_response (system, rpc, request)); + ASSERT_EQ (receive.hash ().to_string (), response3.get ("hash")); + ASSERT_TIMELY (10s, node2.latest (nano::dev::genesis_key.pub) == receive.hash ()); } TEST (rpc, process_ledger_insufficient_work) { nano::system system; - auto & node = *add_ipc_enabled_node (system); - ASSERT_LT (node.network_params.network.publish_thresholds.entry, node.network_params.network.publish_thresholds.epoch_1); - auto latest (node.latest (nano::dev_genesis_key.pub)); - auto min_difficulty = node.network_params.network.publish_thresholds.entry; - auto max_difficulty = node.network_params.network.publish_thresholds.epoch_1; - nano::state_block send (nano::genesis_account, latest, nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, system.work_generate_limited (latest, min_difficulty, max_difficulty)); - ASSERT_LT (send.difficulty (), max_difficulty); - ASSERT_GE (send.difficulty (), min_difficulty); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node); + ASSERT_LT (node->network_params.work.entry, node->network_params.work.epoch_1); + auto latest (node->latest (nano::dev::genesis_key.pub)); + auto min_difficulty = node->network_params.work.entry; + auto max_difficulty = node->network_params.work.epoch_1; + nano::state_block send (nano::dev::genesis->account (), latest, nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, system.work_generate_limited (latest, min_difficulty, max_difficulty)); + ASSERT_LT (nano::dev::network_params.work.difficulty (send), max_difficulty); + ASSERT_GE (nano::dev::network_params.work.difficulty (send), min_difficulty); boost::property_tree::ptree request; request.put ("action", "process"); std::string json; send.serialize_json (json); request.put ("block", json); request.put ("subtype", "send"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::error_code ec (nano::error_process::insufficient_work); - ASSERT_EQ (1, response.json.count ("error")); - ASSERT_EQ (response.json.get ("error"), ec.message ()); + ASSERT_EQ (1, response.count ("error")); + ASSERT_EQ (response.get ("error"), ec.message ()); } TEST (rpc, keepalive) @@ -2108,14 +1671,7 @@ TEST (rpc, keepalive) auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); node1->start (); system.nodes.push_back (node1); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node0, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node0->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node0); boost::property_tree::ptree request; request.put ("action", "keepalive"); auto address (boost::str (boost::format ("%1%") % node1->network.endpoint ().address ())); @@ -2124,9 +1680,7 @@ TEST (rpc, keepalive) request.put ("port", port); ASSERT_EQ (nullptr, node0->network.udp_channels.channel (node1->network.endpoint ())); ASSERT_EQ (0, node0->network.size ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); system.deadline_set (10s); while (node0->network.find_channel (node1->network.endpoint ()) == nullptr) { @@ -2142,28 +1696,19 @@ TEST (rpc, peers) auto node = add_ipc_enabled_node (system); auto port = nano::get_available_port (); system.add_node (nano::node_config (port, system.logging)); - scoped_io_thread_name_change scoped_thread_name_io; nano::endpoint endpoint (boost::asio::ip::make_address_v6 ("fc00::1"), 4000); - node->network.udp_channels.insert (endpoint, node->network_params.protocol.protocol_version); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + node->network.udp_channels.insert (endpoint, node->network_params.network.protocol_version); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "peers"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & peers_node (response.json.get_child ("peers")); + auto response (wait_response (system, rpc, request)); + auto & peers_node (response.get_child ("peers")); ASSERT_EQ (2, peers_node.size ()); - ASSERT_EQ (std::to_string (node->network_params.protocol.protocol_version), peers_node.get ((boost::format ("[::1]:%1%") % port).str ())); + ASSERT_EQ (std::to_string (node->network_params.network.protocol_version), peers_node.get ((boost::format ("[::1]:%1%") % port).str ())); // Previously "[::ffff:80.80.80.80]:4000", but IPv4 address cause "No such node thrown in the test body" issue with peers_node.get std::stringstream endpoint_text; endpoint_text << endpoint; - ASSERT_EQ (std::to_string (node->network_params.protocol.protocol_version), peers_node.get (endpoint_text.str ())); + ASSERT_EQ (std::to_string (node->network_params.network.protocol_version), peers_node.get (endpoint_text.str ())); } TEST (rpc, peers_node_id) @@ -2172,31 +1717,22 @@ TEST (rpc, peers_node_id) auto node = add_ipc_enabled_node (system); auto port = nano::get_available_port (); system.add_node (nano::node_config (port, system.logging)); - scoped_io_thread_name_change scoped_thread_name_io; nano::endpoint endpoint (boost::asio::ip::make_address_v6 ("fc00::1"), 4000); - node->network.udp_channels.insert (endpoint, node->network_params.protocol.protocol_version); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + node->network.udp_channels.insert (endpoint, node->network_params.network.protocol_version); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "peers"); request.put ("peer_details", true); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & peers_node (response.json.get_child ("peers")); + auto response (wait_response (system, rpc, request)); + auto & peers_node (response.get_child ("peers")); ASSERT_EQ (2, peers_node.size ()); auto tree1 (peers_node.get_child ((boost::format ("[::1]:%1%") % port).str ())); - ASSERT_EQ (std::to_string (node->network_params.protocol.protocol_version), tree1.get ("protocol_version")); + ASSERT_EQ (std::to_string (node->network_params.network.protocol_version), tree1.get ("protocol_version")); ASSERT_EQ (system.nodes[1]->node_id.pub.to_node_id (), tree1.get ("node_id")); std::stringstream endpoint_text; endpoint_text << endpoint; auto tree2 (peers_node.get_child (endpoint_text.str ())); - ASSERT_EQ (std::to_string (node->network_params.protocol.protocol_version), tree2.get ("protocol_version")); + ASSERT_EQ (std::to_string (node->network_params.network.protocol_version), tree2.get ("protocol_version")); ASSERT_EQ ("", tree2.get ("node_id")); } @@ -2205,38 +1741,27 @@ TEST (rpc, pending) nano::system system; auto node = add_ipc_enabled_node (system); nano::keypair key1; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto block1 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key1.pub, 100)); - scoped_io_thread_name_change scoped_thread_name_io; + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto block1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 100)); node->scheduler.flush (); ASSERT_TIMELY (5s, !node->active.active (*block1)); ASSERT_TIMELY (5s, node->ledger.cache.cemented_count == 2 && node->confirmation_height_processor.current ().is_zero () && node->confirmation_height_processor.awaiting_processing_size () == 0); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "pending"); request.put ("account", key1.pub.to_account ()); request.put ("count", "100"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & blocks_node (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + auto & blocks_node (response.get_child ("blocks")); ASSERT_EQ (1, blocks_node.size ()); nano::block_hash hash (blocks_node.begin ()->second.get ("")); ASSERT_EQ (block1->hash (), hash); } request.put ("sorting", "true"); // Sorting test { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & blocks_node (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + auto & blocks_node (response.get_child ("blocks")); ASSERT_EQ (1, blocks_node.size ()); nano::block_hash hash (blocks_node.begin ()->first); ASSERT_EQ (block1->hash (), hash); @@ -2245,10 +1770,8 @@ TEST (rpc, pending) } request.put ("threshold", "100"); // Threshold test { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & blocks_node (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + auto & blocks_node (response.get_child ("blocks")); ASSERT_EQ (1, blocks_node.size ()); std::unordered_map blocks; for (auto i (blocks_node.begin ()), j (blocks_node.end ()); i != j; ++i) @@ -2267,20 +1790,16 @@ TEST (rpc, pending) } request.put ("threshold", "101"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & blocks_node (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request, 10s)); + auto & blocks_node (response.get_child ("blocks")); ASSERT_EQ (0, blocks_node.size ()); } request.put ("threshold", "0"); request.put ("source", "true"); request.put ("min_version", "true"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & blocks_node (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + auto & blocks_node (response.get_child ("blocks")); ASSERT_EQ (1, blocks_node.size ()); std::unordered_map amounts; std::unordered_map sources; @@ -2293,38 +1812,35 @@ TEST (rpc, pending) ASSERT_EQ (i->second.get ("min_version"), 0); } ASSERT_EQ (amounts[block1->hash ()], 100); - ASSERT_EQ (sources[block1->hash ()], nano::dev_genesis_key.pub); + ASSERT_EQ (sources[block1->hash ()], nano::dev::genesis_key.pub); } request.put ("account", key1.pub.to_account ()); request.put ("source", "false"); request.put ("min_version", "false"); - auto check_block_response_count = [&system, &request, &rpc] (size_t size) { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - - ASSERT_EQ (200, response.status); - ASSERT_EQ (size, response.json.get_child ("blocks").size ()); + auto check_block_response_count_l = [&system, &request, rpc = rpc] (size_t size) { + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (size, response.get_child ("blocks").size ()); }; - check_block_response_count (1); - scoped_thread_name_io.reset (); + check_block_response_count_l (1); + rpc_ctx->io_scope->reset (); reset_confirmation_height (system.nodes.front ()->store, block1->account ()); - scoped_thread_name_io.renew (); - check_block_response_count (0); + rpc_ctx->io_scope->renew (); + check_block_response_count_l (0); request.put ("include_only_confirmed", "false"); - scoped_thread_name_io.renew (); - check_block_response_count (1); + rpc_ctx->io_scope->renew (); + check_block_response_count_l (1); request.put ("include_only_confirmed", "true"); // Sorting with a smaller count than total should give absolute sorted amounts - scoped_thread_name_io.reset (); - node->store.confirmation_height_put (node->store.tx_begin_write (), nano::dev_genesis_key.pub, { 2, block1->hash () }); - auto block2 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key1.pub, 200)); - auto block3 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key1.pub, 300)); - auto block4 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key1.pub, 400)); - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->reset (); + node->store.confirmation_height.put (node->store.tx_begin_write (), nano::dev::genesis_key.pub, { 2, block1->hash () }); + auto block2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 200)); + auto block3 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 300)); + auto block4 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 400)); + rpc_ctx->io_scope->renew (); ASSERT_TIMELY (10s, node->ledger.account_pending (node->store.tx_begin_read (), key1.pub) == 1000); ASSERT_TIMELY (5s, !node->active.active (*block4)); @@ -2333,10 +1849,8 @@ TEST (rpc, pending) request.put ("count", "2"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & blocks_node (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + auto & blocks_node (response.get_child ("blocks")); ASSERT_EQ (2, blocks_node.size ()); nano::block_hash hash (blocks_node.begin ()->first); nano::block_hash hash1 ((++blocks_node.begin ())->first); @@ -2349,29 +1863,19 @@ TEST (rpc, pending_burn) { nano::system system; auto node = add_ipc_enabled_node (system); - nano::account burn (0); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto block1 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, burn, 100)); - scoped_io_thread_name_change scoped_thread_name_io; + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto block1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::constants.burn_account, 100)); + auto [rpc, rpc_ctx] = add_rpc (system, node); node->scheduler.flush (); ASSERT_TIMELY (5s, !node->active.active (*block1)); ASSERT_TIMELY (5s, node->ledger.cache.cemented_count == 2 && node->confirmation_height_processor.current ().is_zero () && node->confirmation_height_processor.awaiting_processing_size () == 0); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); boost::property_tree::ptree request; request.put ("action", "pending"); - request.put ("account", burn.to_account ()); + request.put ("account", nano::dev::constants.burn_account.to_account ()); request.put ("count", "100"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & blocks_node (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + auto & blocks_node (response.get_child ("blocks")); ASSERT_EQ (1, blocks_node.size ()); nano::block_hash hash (blocks_node.begin ()->second.get ("")); ASSERT_EQ (block1->hash (), hash); @@ -2382,63 +1886,43 @@ TEST (rpc, search_pending) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto wallet (node->wallets.items.begin ()->first.to_string ()); - auto latest (node->latest (nano::dev_genesis_key.pub)); - nano::send_block block (latest, nano::dev_genesis_key.pub, nano::genesis_amount - node->config.receive_minimum.number (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node->work_generate_blocking (latest)); + auto latest (node->latest (nano::dev::genesis_key.pub)); + nano::send_block block (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - node->config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (latest)); { auto transaction (node->store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, block).code); } - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "search_pending"); request.put ("wallet", wallet); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_TIMELY (10s, node->balance (nano::dev_genesis_key.pub) == nano::genesis_amount); + auto response (wait_response (system, rpc, request)); + ASSERT_TIMELY (10s, node->balance (nano::dev::genesis_key.pub) == nano::dev::constants.genesis_amount); } TEST (rpc, version) { nano::system system; auto node1 = add_ipc_enabled_node (system); - nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - system.wallet (0)->insert_adhoc (key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request1; request1.put ("action", "version"); - test_response response1 (request1, rpc.config.port, system.io_ctx); + test_response response1 (request1, rpc->config.port, system.io_ctx); ASSERT_TIMELY (5s, response1.status != 0); ASSERT_EQ (200, response1.status); ASSERT_EQ ("1", response1.json.get ("rpc_version")); - ASSERT_EQ (200, response1.status); { auto transaction (node1->store.tx_begin_read ()); - ASSERT_EQ (std::to_string (node1->store.version_get (transaction)), response1.json.get ("store_version")); + ASSERT_EQ (std::to_string (node1->store.version.get (transaction)), response1.json.get ("store_version")); } - ASSERT_EQ (std::to_string (node1->network_params.protocol.protocol_version), response1.json.get ("protocol_version")); + ASSERT_EQ (std::to_string (node1->network_params.network.protocol_version), response1.json.get ("protocol_version")); ASSERT_EQ (boost::str (boost::format ("Banano %1%") % NANO_VERSION_STRING), response1.json.get ("node_vendor")); ASSERT_EQ (node1->store.vendor_get (), response1.json.get ("store_vendor")); auto network_label (node1->network_params.network.get_current_network_as_string ()); ASSERT_EQ (network_label, response1.json.get ("network")); - auto genesis_open (node1->latest (nano::dev_genesis_key.pub)); + auto genesis_open (node1->latest (nano::dev::genesis_key.pub)); ASSERT_EQ (genesis_open.to_string (), response1.json.get ("network_identifier")); ASSERT_EQ (BUILD_INFO, response1.json.get ("build_info")); auto headers (response1.resp.base ()); @@ -2460,30 +1944,20 @@ TEST (rpc, work_generate) { nano::system system; auto node = add_ipc_enabled_node (system); - nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - system.wallet (0)->insert_adhoc (key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); nano::block_hash hash (1); boost::property_tree::ptree request; request.put ("action", "work_generate"); request.put ("hash", hash.to_string ()); - auto verify_response = [node, &rpc, &system] (auto & request, auto & hash) { - test_response response (request, rpc.config.port, system.io_ctx); + auto verify_response = [node, rpc = rpc, &system] (auto & request, auto & hash) { + test_response response (request, rpc->config.port, system.io_ctx); ASSERT_TIMELY (5s, response.status != 0); ASSERT_EQ (200, response.status); ASSERT_EQ (hash.to_string (), response.json.get ("hash")); auto work_text (response.json.get ("work")); uint64_t work; ASSERT_FALSE (nano::from_string_hex (work_text, work)); - auto result_difficulty (nano::work_difficulty (nano::work_version::work_1, hash, work)); + auto result_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, work)); auto response_difficulty_text (response.json.get ("difficulty")); uint64_t response_difficulty; ASSERT_FALSE (nano::from_string_hex (response_difficulty_text, response_difficulty)); @@ -2501,15 +1975,8 @@ TEST (rpc, work_generate_difficulty) nano::system system; nano::node_config node_config (nano::get_available_port (), system.logging); node_config.max_work_generate_multiplier = 1000; - auto node = add_ipc_enabled_node (system, node_config); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node); nano::block_hash hash (1); boost::property_tree::ptree request; request.put ("action", "work_generate"); @@ -2517,18 +1984,16 @@ TEST (rpc, work_generate_difficulty) { uint64_t difficulty (0xfff0000000000000); request.put ("difficulty", nano::to_string_hex (difficulty)); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - auto work_text (response.json.get ("work")); + auto response (wait_response (system, rpc, request, 10s)); + auto work_text (response.get ("work")); uint64_t work; ASSERT_FALSE (nano::from_string_hex (work_text, work)); - auto result_difficulty (nano::work_difficulty (nano::work_version::work_1, hash, work)); - auto response_difficulty_text (response.json.get ("difficulty")); + auto result_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, work)); + auto response_difficulty_text (response.get ("difficulty")); uint64_t response_difficulty; ASSERT_FALSE (nano::from_string_hex (response_difficulty_text, response_difficulty)); ASSERT_EQ (result_difficulty, response_difficulty); - auto multiplier = response.json.get ("multiplier"); + auto multiplier = response.get ("multiplier"); // Expected multiplier from base threshold, not from the given difficulty ASSERT_NEAR (nano::difficulty::to_multiplier (result_difficulty, node->default_difficulty (nano::work_version::work_1)), multiplier, 1e-10); ASSERT_GE (result_difficulty, difficulty); @@ -2536,23 +2001,19 @@ TEST (rpc, work_generate_difficulty) { uint64_t difficulty (0xffff000000000000); request.put ("difficulty", nano::to_string_hex (difficulty)); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (20s, response.status != 0); - ASSERT_EQ (200, response.status); - auto work_text (response.json.get ("work")); + auto response (wait_response (system, rpc, request)); + auto work_text (response.get ("work")); uint64_t work; ASSERT_FALSE (nano::from_string_hex (work_text, work)); - auto result_difficulty (nano::work_difficulty (nano::work_version::work_1, hash, work)); + auto result_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, work)); ASSERT_GE (result_difficulty, difficulty); } { uint64_t difficulty (node->max_work_generate_difficulty (nano::work_version::work_1) + 1); request.put ("difficulty", nano::to_string_hex (difficulty)); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::error_code ec (nano::error_rpc::difficulty_limit); - ASSERT_EQ (response.json.get ("error"), ec.message ()); + ASSERT_EQ (response.get ("error"), ec.message ()); } } @@ -2562,14 +2023,7 @@ TEST (rpc, work_generate_multiplier) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.max_work_generate_multiplier = 100; auto node = add_ipc_enabled_node (system, node_config); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); nano::block_hash hash (1); boost::property_tree::ptree request; request.put ("action", "work_generate"); @@ -2580,37 +2034,31 @@ TEST (rpc, work_generate_multiplier) request.put ("difficulty", nano::to_string_hex (0xff00000000000000)); double multiplier{ 100.0 }; request.put ("multiplier", multiplier); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - auto work_text (response.json.get_optional ("work")); + auto response (wait_response (system, rpc, request, 10s)); + auto work_text (response.get_optional ("work")); ASSERT_TRUE (work_text.is_initialized ()); uint64_t work; ASSERT_FALSE (nano::from_string_hex (*work_text, work)); - auto result_difficulty (nano::work_difficulty (nano::work_version::work_1, hash, work)); - auto response_difficulty_text (response.json.get ("difficulty")); + auto result_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, work)); + auto response_difficulty_text (response.get ("difficulty")); uint64_t response_difficulty; ASSERT_FALSE (nano::from_string_hex (response_difficulty_text, response_difficulty)); ASSERT_EQ (result_difficulty, response_difficulty); - auto result_multiplier = response.json.get ("multiplier"); + auto result_multiplier = response.get ("multiplier"); ASSERT_GE (result_multiplier, multiplier); } { request.put ("multiplier", -1.5); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::error_code ec (nano::error_rpc::bad_multiplier_format); - ASSERT_EQ (response.json.get ("error"), ec.message ()); + ASSERT_EQ (response.get ("error"), ec.message ()); } { double max_multiplier (nano::difficulty::to_multiplier (node->max_work_generate_difficulty (nano::work_version::work_1), node->default_difficulty (nano::work_version::work_1))); request.put ("multiplier", max_multiplier + 1); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::error_code ec (nano::error_rpc::difficulty_limit); - ASSERT_EQ (response.json.get ("error"), ec.message ()); + ASSERT_EQ (response.get ("error"), ec.message ()); } } @@ -2618,18 +2066,11 @@ TEST (rpc, work_generate_block_high) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); nano::keypair key; - nano::state_block block (key.pub, 0, nano::dev_genesis_key.pub, nano::MBAN_ratio, 123, key.prv, key.pub, *node->work_generate_blocking (key.pub)); + nano::state_block block (key.pub, 0, nano::dev::genesis_key.pub, nano::MBAN_ratio, 123, key.prv, key.pub, *node->work_generate_blocking (key.pub)); nano::block_hash hash (block.root ().as_block_hash ()); - auto block_difficulty (nano::work_difficulty (nano::work_version::work_1, hash, block.block_work ())); + auto block_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, block.block_work ())); boost::property_tree::ptree request; request.put ("action", "work_generate"); request.put ("hash", hash.to_string ()); @@ -2638,11 +2079,9 @@ TEST (rpc, work_generate_block_high) block.serialize_json (json); request.add_child ("block", json); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (1, response.json.count ("error")); - ASSERT_EQ (std::error_code (nano::error_rpc::block_work_enough).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (1, response.count ("error")); + ASSERT_EQ (std::error_code (nano::error_rpc::block_work_enough).message (), response.get ("error")); } } @@ -2650,20 +2089,13 @@ TEST (rpc, work_generate_block_low) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); nano::keypair key; - nano::state_block block (key.pub, 0, nano::dev_genesis_key.pub, nano::MBAN_ratio, 123, key.prv, key.pub, 0); + nano::state_block block (key.pub, 0, nano::dev::genesis_key.pub, nano::MBAN_ratio, 123, key.prv, key.pub, 0); auto threshold (node->default_difficulty (block.work_version ())); block.block_work_set (system.work_generate_limited (block.root ().as_block_hash (), threshold, nano::difficulty::from_multiplier (node->config.max_work_generate_multiplier / 10, threshold))); nano::block_hash hash (block.root ().as_block_hash ()); - auto block_difficulty (block.difficulty ()); + auto block_difficulty (nano::dev::network_params.work.difficulty (block)); boost::property_tree::ptree request; request.put ("action", "work_generate"); request.put ("hash", hash.to_string ()); @@ -2673,16 +2105,14 @@ TEST (rpc, work_generate_block_low) block.serialize_json (json); request.put ("block", json); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - auto work_text (response.json.get_optional ("work")); + auto response (wait_response (system, rpc, request, 10s)); + auto work_text (response.get_optional ("work")); ASSERT_TRUE (work_text.is_initialized ()); uint64_t work; ASSERT_FALSE (nano::from_string_hex (*work_text, work)); ASSERT_NE (block.block_work (), work); - auto result_difficulty (nano::work_difficulty (nano::work_version::work_1, hash, work)); - auto response_difficulty_text (response.json.get ("difficulty")); + auto result_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, work)); + auto response_difficulty_text (response.get ("difficulty")); uint64_t response_difficulty; ASSERT_FALSE (nano::from_string_hex (response_difficulty_text, response_difficulty)); ASSERT_EQ (result_difficulty, response_difficulty); @@ -2694,16 +2124,9 @@ TEST (rpc, work_generate_block_root_mismatch) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); nano::keypair key; - nano::state_block block (key.pub, 0, nano::dev_genesis_key.pub, nano::MBAN_ratio, 123, key.prv, key.pub, *node->work_generate_blocking (key.pub)); + nano::state_block block (key.pub, 0, nano::dev::genesis_key.pub, nano::MBAN_ratio, 123, key.prv, key.pub, *node->work_generate_blocking (key.pub)); nano::block_hash hash (1); boost::property_tree::ptree request; request.put ("action", "work_generate"); @@ -2713,11 +2136,9 @@ TEST (rpc, work_generate_block_root_mismatch) block.serialize_json (json); request.put ("block", json); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (1, response.json.count ("error")); - ASSERT_EQ (std::error_code (nano::error_rpc::block_root_mismatch).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (1, response.count ("error")); + ASSERT_EQ (std::error_code (nano::error_rpc::block_root_mismatch).message (), response.get ("error")); } } @@ -2730,21 +2151,14 @@ TEST (rpc, work_generate_block_ledger_epoch_2) auto epoch2 = system.upgrade_genesis_epoch (*node, nano::epoch::epoch_2); ASSERT_NE (nullptr, epoch2); nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto send_block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, nano::MBAN_ratio)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto send_block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::MBAN_ratio)); ASSERT_NE (nullptr, send_block); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); - nano::state_block block (key.pub, 0, nano::dev_genesis_key.pub, nano::MBAN_ratio, send_block->hash (), key.prv, key.pub, 0); - auto threshold (nano::work_threshold (block.work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); + nano::state_block block (key.pub, 0, nano::dev::genesis_key.pub, nano::MBAN_ratio, send_block->hash (), key.prv, key.pub, 0); + auto threshold (nano::dev::network_params.work.threshold (block.work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); block.block_work_set (system.work_generate_limited (block.root ().as_block_hash (), 1, threshold - 1)); nano::block_hash hash (block.root ().as_block_hash ()); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "work_generate"); request.put ("hash", hash.to_string ()); @@ -2756,20 +2170,18 @@ TEST (rpc, work_generate_block_ledger_epoch_2) auto iteration (0); while (!finished) { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - auto work_text (response.json.get_optional ("work")); + auto response (wait_response (system, rpc, request, 10s)); + auto work_text (response.get_optional ("work")); ASSERT_TRUE (work_text.is_initialized ()); uint64_t work; ASSERT_FALSE (nano::from_string_hex (*work_text, work)); - auto result_difficulty (nano::work_difficulty (nano::work_version::work_1, hash, work)); - auto response_difficulty_text (response.json.get ("difficulty")); + auto result_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, work)); + auto response_difficulty_text (response.get ("difficulty")); uint64_t response_difficulty; ASSERT_FALSE (nano::from_string_hex (response_difficulty_text, response_difficulty)); ASSERT_EQ (result_difficulty, response_difficulty); - ASSERT_GE (result_difficulty, node->network_params.network.publish_thresholds.epoch_2_receive); - finished = result_difficulty < node->network_params.network.publish_thresholds.epoch_1; + ASSERT_GE (result_difficulty, node->network_params.work.epoch_2_receive); + finished = result_difficulty < node->network_params.work.epoch_1; ASSERT_LT (++iteration, 200); } } @@ -2777,18 +2189,8 @@ TEST (rpc, work_generate_block_ledger_epoch_2) TEST (rpc, work_cancel) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - system.wallet (0)->insert_adhoc (key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); nano::block_hash hash1 (1); boost::property_tree::ptree request1; request1.put ("action", "work_cancel"); @@ -2797,15 +2199,13 @@ TEST (rpc, work_cancel) system.deadline_set (10s); while (!done) { - system.work.generate (nano::work_version::work_1, hash1, node1.network_params.network.publish_thresholds.base, [&done] (boost::optional work_a) { + system.work.generate (nano::work_version::work_1, hash1, node1->network_params.work.base, [&done] (boost::optional work_a) { done = !work_a; }); - test_response response1 (request1, rpc.config.port, system.io_ctx); + auto response1 (wait_response (system, rpc, request1)); std::error_code ec; - ASSERT_TIMELY (10s, response1.status != 0); - ASSERT_EQ (200, response1.status); ASSERT_NO_ERROR (ec); - std::string success (response1.json.get ("success")); + std::string success (response1.get ("success")); ASSERT_TRUE (success.empty ()); } } @@ -2813,53 +2213,33 @@ TEST (rpc, work_cancel) TEST (rpc, work_peer_bad) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); + auto node1 = add_ipc_enabled_node (system); auto & node2 = *system.add_node (); - nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - system.wallet (0)->insert_adhoc (key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); node2.config.work_peers.push_back (std::make_pair (boost::asio::ip::address_v6::any ().to_string (), 0)); + auto [rpc, rpc_ctx] = add_rpc (system, node1); nano::block_hash hash1 (1); std::atomic work (0); - node2.work_generate (nano::work_version::work_1, hash1, node2.network_params.network.publish_thresholds.base, [&work] (boost::optional work_a) { + node2.work_generate (nano::work_version::work_1, hash1, node2.network_params.work.base, [&work] (boost::optional work_a) { ASSERT_TRUE (work_a.is_initialized ()); work = *work_a; }); - ASSERT_TIMELY (5s, nano::work_difficulty (nano::work_version::work_1, hash1, work) >= nano::work_threshold_base (nano::work_version::work_1)); + ASSERT_TIMELY (5s, nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash1, work) >= nano::dev::network_params.work.threshold_base (nano::work_version::work_1)); } TEST (rpc, work_peer_one) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); + auto node1 = add_ipc_enabled_node (system); auto & node2 = *system.add_node (); - nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - system.wallet (0)->insert_adhoc (key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); - node2.config.work_peers.push_back (std::make_pair (node1.network.endpoint ().address ().to_string (), rpc.config.port)); + auto [rpc, rpc_ctx] = add_rpc (system, node1); + node2.config.work_peers.push_back (std::make_pair (node1->network.endpoint ().address ().to_string (), rpc->config.port)); nano::keypair key1; std::atomic work (0); - node2.work_generate (nano::work_version::work_1, key1.pub, node1.network_params.network.publish_thresholds.base, [&work] (boost::optional work_a) { + node2.work_generate (nano::work_version::work_1, key1.pub, node1->network_params.work.base, [&work] (boost::optional work_a) { ASSERT_TRUE (work_a.is_initialized ()); work = *work_a; }); - ASSERT_TIMELY (5s, nano::work_difficulty (nano::work_version::work_1, key1.pub, work) >= nano::work_threshold_base (nano::work_version::work_1)); + ASSERT_TIMELY (5s, nano::dev::network_params.work.difficulty (nano::work_version::work_1, key1.pub, work) >= nano::dev::network_params.work.threshold_base (nano::work_version::work_1)); } TEST (rpc, work_peer_many) @@ -2869,39 +2249,24 @@ TEST (rpc, work_peer_many) nano::system system3 (1); nano::system system4 (1); auto & node1 (*system1.nodes[0]); - auto & node2 = *add_ipc_enabled_node (system2); - auto & node3 = *add_ipc_enabled_node (system3); - auto & node4 = *add_ipc_enabled_node (system4); - nano::keypair key; - nano::rpc_config config2 (nano::get_available_port (), true); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server2 (node2, node_rpc_config); - nano::ipc_rpc_processor ipc_rpc_processor2 (system2.io_ctx, config2); - nano::rpc rpc2 (system2.io_ctx, config2, ipc_rpc_processor2); - rpc2.start (); - nano::rpc_config config3 (nano::get_available_port (), true); - nano::ipc::ipc_server ipc_server3 (node3, node_rpc_config); - nano::ipc_rpc_processor ipc_rpc_processor3 (system3.io_ctx, config3); - nano::rpc rpc3 (system3.io_ctx, config3, ipc_rpc_processor3); - rpc3.start (); - nano::rpc_config config4 (nano::get_available_port (), true); - nano::ipc::ipc_server ipc_server4 (node4, node_rpc_config); - nano::ipc_rpc_processor ipc_rpc_processor4 (system4.io_ctx, config4); - nano::rpc rpc4 (system2.io_ctx, config4, ipc_rpc_processor4); - rpc4.start (); - node1.config.work_peers.push_back (std::make_pair (node2.network.endpoint ().address ().to_string (), rpc2.config.port)); - node1.config.work_peers.push_back (std::make_pair (node3.network.endpoint ().address ().to_string (), rpc3.config.port)); - node1.config.work_peers.push_back (std::make_pair (node4.network.endpoint ().address ().to_string (), rpc4.config.port)); + auto node2 = add_ipc_enabled_node (system2); + auto node3 = add_ipc_enabled_node (system3); + auto node4 = add_ipc_enabled_node (system4); + auto [rpc2, rpc_ctx_2] = add_rpc (system2, node2); + auto [rpc3, rpc_ctx_3] = add_rpc (system3, node3); + auto [rpc4, rpc_ctx_4] = add_rpc (system4, node4); + node1.config.work_peers.push_back (std::make_pair (node2->network.endpoint ().address ().to_string (), rpc2->config.port)); + node1.config.work_peers.push_back (std::make_pair (node3->network.endpoint ().address ().to_string (), rpc3->config.port)); + node1.config.work_peers.push_back (std::make_pair (node4->network.endpoint ().address ().to_string (), rpc4->config.port)); std::array, 10> works; for (auto i (0); i < works.size (); ++i) { nano::keypair key1; - node1.work_generate (nano::work_version::work_1, key1.pub, node1.network_params.network.publish_thresholds.base, [&work = works[i]] (boost::optional work_a) { + node1.work_generate (nano::work_version::work_1, key1.pub, node1.network_params.work.base, [&work = works[i]] (boost::optional work_a) { work = *work_a; }); - while (nano::work_difficulty (nano::work_version::work_1, key1.pub, works[i]) < nano::work_threshold_base (nano::work_version::work_1)) + while (nano::dev::network_params.work.difficulty (nano::work_version::work_1, key1.pub, works[i]) < nano::dev::network_params.work.threshold_base (nano::work_version::work_1)) { system1.poll (); system2.poll (); @@ -2916,33 +2281,22 @@ TEST (rpc, work_version_invalid) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); nano::block_hash hash (1); boost::property_tree::ptree request; request.put ("action", "work_generate"); request.put ("hash", hash.to_string ()); request.put ("version", "work_invalid"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (1, response.json.count ("error")); - ASSERT_EQ (std::error_code (nano::error_rpc::bad_work_version).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (1, response.count ("error")); + ASSERT_EQ (std::error_code (nano::error_rpc::bad_work_version).message (), response.get ("error")); } request.put ("action", "work_validate"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (1, response.json.count ("error")); - ASSERT_EQ (std::error_code (nano::error_rpc::bad_work_version).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (1, response.count ("error")); + ASSERT_EQ (std::error_code (nano::error_rpc::bad_work_version).message (), response.get ("error")); } } @@ -2950,47 +2304,30 @@ TEST (rpc, block_count) { { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request1; request1.put ("action", "block_count"); { - test_response response1 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response1.status != 0); - ASSERT_EQ (200, response1.status); - ASSERT_EQ ("1", response1.json.get ("count")); - ASSERT_EQ ("0", response1.json.get ("unchecked")); - ASSERT_EQ ("1", response1.json.get ("cemented")); + auto response1 (wait_response (system, rpc, request1)); + ASSERT_EQ ("1", response1.get ("count")); + ASSERT_EQ ("0", response1.get ("unchecked")); + ASSERT_EQ ("1", response1.get ("cemented")); } } // Should be able to get all counts even when enable_control is false. { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config; - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request1; request1.put ("action", "block_count"); { - test_response response1 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response1.status != 0); - ASSERT_EQ (200, response1.status); - ASSERT_EQ ("1", response1.json.get ("count")); - ASSERT_EQ ("0", response1.json.get ("unchecked")); - ASSERT_EQ ("1", response1.json.get ("cemented")); + auto response1 (wait_response (system, rpc, request1)); + ASSERT_EQ ("1", response1.get ("count")); + ASSERT_EQ ("0", response1.get ("unchecked")); + ASSERT_EQ ("1", response1.get ("cemented")); } } } @@ -3003,296 +2340,183 @@ TEST (rpc, block_count_pruning) node_config.enable_voting = false; // Remove after allowing pruned voting nano::node_flags node_flags; node_flags.enable_pruning = true; - auto & node1 = *add_ipc_enabled_node (system, node_config, node_flags); - auto latest (node1.latest (nano::dev_genesis_key.pub)); - auto send1 (std::make_shared (latest, nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest))); - node1.process_active (send1); - auto receive1 (std::make_shared (send1->hash (), send1->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (send1->hash ()))); - node1.process_active (receive1); - node1.block_processor.flush (); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 3 && node1.confirmation_height_processor.current ().is_zero () && node1.confirmation_height_processor.awaiting_processing_size () == 0); + auto node1 = add_ipc_enabled_node (system, node_config, node_flags); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + auto send1 (std::make_shared (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest))); + node1->process_active (send1); + auto receive1 (std::make_shared (send1->hash (), send1->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (send1->hash ()))); + node1->process_active (receive1); + node1->block_processor.flush (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + ASSERT_TIMELY (5s, node1->ledger.cache.cemented_count == 3 && node1->confirmation_height_processor.current ().is_zero () && node1->confirmation_height_processor.awaiting_processing_size () == 0); // Pruning action { - auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (1, node1.ledger.pruning_action (transaction, send1->hash (), 1)); + auto transaction (node1->store.tx_begin_write ()); + ASSERT_EQ (1, node1->ledger.pruning_action (transaction, send1->hash (), 1)); } - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request1; request1.put ("action", "block_count"); { - test_response response1 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response1.status != 0); - ASSERT_EQ (200, response1.status); - ASSERT_EQ ("3", response1.json.get ("count")); - ASSERT_EQ ("0", response1.json.get ("unchecked")); - ASSERT_EQ ("3", response1.json.get ("cemented")); - ASSERT_EQ ("2", response1.json.get ("full")); - ASSERT_EQ ("1", response1.json.get ("pruned")); + auto response1 (wait_response (system, rpc, request1)); + ASSERT_EQ ("3", response1.get ("count")); + ASSERT_EQ ("0", response1.get ("unchecked")); + ASSERT_EQ ("3", response1.get ("cemented")); + ASSERT_EQ ("2", response1.get ("full")); + ASSERT_EQ ("1", response1.get ("pruned")); } } TEST (rpc, frontier_count) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request1; request1.put ("action", "frontier_count"); - test_response response1 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response1.status != 0); - ASSERT_EQ (200, response1.status); - ASSERT_EQ ("1", response1.json.get ("count")); + auto response1 (wait_response (system, rpc, request1)); + ASSERT_EQ ("1", response1.get ("count")); } TEST (rpc, account_count) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request1; request1.put ("action", "account_count"); - test_response response1 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response1.status != 0); - ASSERT_EQ (200, response1.status); - ASSERT_EQ ("1", response1.json.get ("count")); + auto response1 (wait_response (system, rpc, request1)); + ASSERT_EQ ("1", response1.get ("count")); } TEST (rpc, available_supply) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request1; request1.put ("action", "available_supply"); - test_response response1 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response1.status != 0); - ASSERT_EQ (200, response1.status); - ASSERT_EQ ("0", response1.json.get ("available")); - scoped_thread_name_io.reset (); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + auto response1 (wait_response (system, rpc, request1)); + ASSERT_EQ ("0", response1.get ("available")); + rpc_ctx->io_scope->reset (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key; - auto block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 1)); - scoped_thread_name_io.renew (); - test_response response2 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response2.status != 0); - ASSERT_EQ (200, response2.status); - ASSERT_EQ ("1", response2.json.get ("available")); - scoped_thread_name_io.reset (); - auto block2 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, 0, 100)); // Sending to burning 0 account - scoped_thread_name_io.renew (); - test_response response3 (request1, rpc.config.port, system.io_ctx); - system.deadline_set (5s); - ASSERT_TIMELY (10s, response3.status != 0); - ASSERT_EQ (200, response3.status); - ASSERT_EQ ("1", response3.json.get ("available")); + auto block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 1)); + rpc_ctx->io_scope->renew (); + auto response2 (wait_response (system, rpc, request1)); + ASSERT_EQ ("1", response2.get ("available")); + rpc_ctx->io_scope->reset (); + auto block2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, 0, 100)); // Sending to burning 0 account + rpc_ctx->io_scope->renew (); + auto response3 (wait_response (system, rpc, request1, 10s)); + ASSERT_EQ ("1", response3.get ("available")); } TEST (rpc, ban_to_raw) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request1; request1.put ("action", "ban_to_raw"); request1.put ("amount", "1"); - test_response response1 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response1.status != 0); - ASSERT_EQ (200, response1.status); - ASSERT_EQ (nano::BAN_ratio.convert_to (), response1.json.get ("amount")); + auto response1 (wait_response (system, rpc, request1)); + ASSERT_EQ (nano::BAN_ratio.convert_to (), response1.get ("amount")); } TEST (rpc, ban_from_raw) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request1; - request1.put ("action", "ban_from_raw"); + request1.put ("action", "mrai_from_raw"); request1.put ("amount", nano::BAN_ratio.convert_to ()); - test_response response1 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response1.status != 0); - ASSERT_EQ (200, response1.status); - ASSERT_EQ ("1", response1.json.get ("amount")); + auto response1 (wait_response (system, rpc, request1)); + ASSERT_EQ ("1", response1.get ("amount")); } TEST (rpc, banoshi_to_raw) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request1; request1.put ("action", "banoshi_to_raw"); request1.put ("amount", "1"); - test_response response1 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response1.status != 0); - ASSERT_EQ (200, response1.status); - ASSERT_EQ (nano::banoshi_ratio.convert_to (), response1.json.get ("amount")); + auto response1 (wait_response (system, rpc, request1)); + ASSERT_EQ (nano::banoshi_ratio.convert_to (), response1.get ("amount")); } TEST (rpc, banoshi_from_raw) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request1; - request1.put ("action", "banoshi_from_raw"); + request1.put ("action", "krai_from_raw"); request1.put ("amount", nano::banoshi_ratio.convert_to ()); - test_response response1 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response1.status != 0); - ASSERT_EQ (200, response1.status); - ASSERT_EQ ("1", response1.json.get ("amount")); + auto response1 (wait_response (system, rpc, request1)); + ASSERT_EQ ("1", response1.get ("amount")); } TEST (rpc, nano_to_raw) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request1; request1.put ("action", "nano_to_raw"); request1.put ("amount", "1"); - test_response response1 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response1.status != 0); - ASSERT_EQ (200, response1.status); - ASSERT_EQ (nano::RAW_ratio.convert_to (), response1.json.get ("amount")); + auto response1 (wait_response (system, rpc, request1)); + ASSERT_EQ (nano::BAN_ratio.convert_to (), response1.get ("amount")); } -TEST (rpc, nano_from_raw) +TEST (rpc, raw_to_nano) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request1; - request1.put ("action", "nano_from_raw"); - request1.put ("amount", nano::RAW_ratio.convert_to ()); - test_response response1 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response1.status != 0); - ASSERT_EQ (200, response1.status); - ASSERT_EQ ("1", response1.json.get ("amount")); + request1.put ("action", "raw_to_nano"); + request1.put ("amount", nano::BAN_ratio.convert_to ()); + auto response1 (wait_response (system, rpc, request1)); + ASSERT_EQ ("1", response1.get ("amount")); } TEST (rpc, account_representative) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; - request.put ("account", nano::genesis_account.to_account ()); + request.put ("account", nano::dev::genesis->account ().to_account ()); request.put ("action", "account_representative"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string account_text1 (response.json.get ("representative")); - ASSERT_EQ (account_text1, nano::genesis_account.to_account ()); + auto response (wait_response (system, rpc, request)); + std::string account_text1 (response.get ("representative")); + ASSERT_EQ (account_text1, nano::dev::genesis->account ().to_account ()); } TEST (rpc, account_representative_set) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; nano::keypair rep; - request.put ("account", nano::genesis_account.to_account ()); + request.put ("account", nano::dev::genesis->account ().to_account ()); request.put ("representative", rep.pub.to_account ()); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); request.put ("action", "account_representative_set"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string block_text1 (response.json.get ("block")); + auto response (wait_response (system, rpc, request)); + std::string block_text1 (response.get ("block")); nano::block_hash hash; ASSERT_FALSE (hash.decode_hex (block_text1)); ASSERT_FALSE (hash.is_zero ()); auto transaction (node->store.tx_begin_read ()); - ASSERT_TRUE (node->store.block_exists (transaction, hash)); - ASSERT_EQ (rep.pub, node->store.block_get (transaction, hash)->representative ()); + ASSERT_TRUE (node->store.block.exists (transaction, hash)); + ASSERT_EQ (rep.pub, node->store.block.get (transaction, hash)->representative ()); } TEST (rpc, account_representative_set_work_disabled) @@ -3300,71 +2524,53 @@ TEST (rpc, account_representative_set_work_disabled) nano::system system; nano::node_config node_config (nano::get_available_port (), system.logging); node_config.work_threads = 0; - auto & node = *add_ipc_enabled_node (system, node_config); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node = add_ipc_enabled_node (system, node_config); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; nano::keypair rep; - request.put ("account", nano::genesis_account.to_account ()); + request.put ("account", nano::dev::genesis->account ().to_account ()); request.put ("representative", rep.pub.to_account ()); - request.put ("wallet", node.wallets.items.begin ()->first.to_string ()); + request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); request.put ("action", "account_representative_set"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_common::disabled_work_generation).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request, 10s)); + ASSERT_EQ (std::error_code (nano::error_common::disabled_work_generation).message (), response.get ("error")); } } TEST (rpc, account_representative_set_epoch_2) { nano::system system; - auto & node = *add_ipc_enabled_node (system); + auto node = add_ipc_enabled_node (system); // Upgrade the genesis account to epoch 2 - ASSERT_NE (nullptr, system.upgrade_genesis_epoch (node, nano::epoch::epoch_1)); - ASSERT_NE (nullptr, system.upgrade_genesis_epoch (node, nano::epoch::epoch_2)); + ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_1)); + ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_2)); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv, false); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv, false); - auto target_difficulty = nano::work_threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, false, false, false)); - ASSERT_LT (node.network_params.network.publish_thresholds.entry, target_difficulty); - auto min_difficulty = node.network_params.network.publish_thresholds.entry; + auto target_difficulty = nano::dev::network_params.work.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, false, false, false)); + ASSERT_LT (node->network_params.work.entry, target_difficulty); + auto min_difficulty = node->network_params.work.entry; - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; - node.wallets.items.begin ()->first.encode_hex (wallet); + node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "account_representative_set"); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); request.put ("representative", nano::keypair ().pub.to_account ()); // Test that the correct error is given if there is insufficient work - auto insufficient = system.work_generate_limited (nano::genesis_hash, min_difficulty, target_difficulty); + auto insufficient = system.work_generate_limited (nano::dev::genesis->hash (), min_difficulty, target_difficulty); request.put ("work", nano::to_string_hex (insufficient)); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::error_code ec (nano::error_common::invalid_work); - ASSERT_EQ (1, response.json.count ("error")); - ASSERT_EQ (response.json.get ("error"), ec.message ()); + ASSERT_EQ (1, response.count ("error")); + ASSERT_EQ (response.get ("error"), ec.message ()); } } @@ -3373,31 +2579,25 @@ TEST (rpc, bootstrap) nano::system system0; auto node = add_ipc_enabled_node (system0); nano::system system1 (1); - auto latest (system1.nodes[0]->latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, nano::genesis_account, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system1.nodes[0]->work_generate_blocking (latest)); + auto node1 = system1.nodes[0]; + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, nano::dev::genesis->account (), 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); { - auto transaction (system1.nodes[0]->store.tx_begin_write ()); - ASSERT_EQ (nano::process_result::progress, system1.nodes[0]->ledger.process (transaction, send).code); + auto transaction (node1->store.tx_begin_write ()); + ASSERT_EQ (nano::process_result::progress, node1->ledger.process (transaction, send).code); } - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system0.io_ctx, rpc_config); - nano::rpc rpc (system0.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system0, node); boost::property_tree::ptree request; request.put ("action", "bootstrap"); request.put ("address", "::ffff:127.0.0.1"); - request.put ("port", system1.nodes[0]->network.endpoint ().port ()); - test_response response (request, rpc.config.port, system0.io_ctx); + request.put ("port", node1->network.endpoint ().port ()); + test_response response (request, rpc->config.port, system0.io_ctx); while (response.status == 0) { system0.poll (); } system1.deadline_set (10s); - while (system0.nodes[0]->latest (nano::genesis_account) != system1.nodes[0]->latest (nano::genesis_account)) + while (node->latest (nano::dev::genesis->account ()) != node1->latest (nano::dev::genesis->account ())) { ASSERT_NO_ERROR (system0.poll ()); ASSERT_NO_ERROR (system1.poll ()); @@ -3409,24 +2609,13 @@ TEST (rpc, account_remove) nano::system system0; auto node = add_ipc_enabled_node (system0); auto key1 (system0.wallet (0)->deterministic_insert ()); - scoped_io_thread_name_change scoped_thread_name_io; ASSERT_TRUE (system0.wallet (0)->exists (key1)); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system0.io_ctx, rpc_config); - nano::rpc rpc (system0.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system0, node); boost::property_tree::ptree request; request.put ("action", "account_remove"); - request.put ("wallet", system0.nodes[0]->wallets.items.begin ()->first.to_string ()); + request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); request.put ("account", key1.to_account ()); - test_response response (request, rpc.config.port, system0.io_ctx); - while (response.status == 0) - { - system0.poll (); - } + auto response (wait_response (system0, rpc, request)); ASSERT_FALSE (system0.wallet (0)->exists (key1)); } @@ -3434,23 +2623,11 @@ TEST (rpc, representatives) { nano::system system0; auto node = add_ipc_enabled_node (system0); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system0.io_ctx, rpc_config); - nano::rpc rpc (system0.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system0, node); boost::property_tree::ptree request; request.put ("action", "representatives"); - test_response response (request, rpc.config.port, system0.io_ctx); - while (response.status == 0) - { - system0.poll (); - } - ASSERT_EQ (200, response.status); - auto & representatives_node (response.json.get_child ("representatives")); + auto response (wait_response (system0, rpc, request)); + auto & representatives_node (response.get_child ("representatives")); std::vector representatives; for (auto i (representatives_node.begin ()), n (representatives_node.end ()); i != n; ++i) { @@ -3459,7 +2636,7 @@ TEST (rpc, representatives) representatives.push_back (account); } ASSERT_EQ (1, representatives.size ()); - ASSERT_EQ (nano::genesis_account, representatives[0]); + ASSERT_EQ (nano::dev::genesis->account (), representatives[0]); } // wallet_seed is only available over IPC's unsafe encoding, and when running on test network @@ -3467,27 +2644,18 @@ TEST (rpc, wallet_seed) { nano::system system; auto node = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node); nano::raw_key seed; { auto transaction (node->wallets.tx_begin_read ()); system.wallet (0)->store.seed (seed, transaction); } - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); boost::property_tree::ptree request; request.put ("action", "wallet_seed"); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); - test_response response (request, rpc_config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); { - std::string seed_text (response.json.get ("seed")); + std::string seed_text (response.get ("seed")); ASSERT_EQ (seed.to_string (), seed_text); } } @@ -3496,165 +2664,120 @@ TEST (rpc, wallet_change_seed) { nano::system system0; auto node = add_ipc_enabled_node (system0); + auto [rpc, rpc_ctx] = add_rpc (system0, node); nano::raw_key seed; nano::random_pool::generate_block (seed.bytes.data (), seed.bytes.size ()); { - auto transaction (system0.nodes[0]->wallets.tx_begin_read ()); + auto transaction (node->wallets.tx_begin_read ()); nano::raw_key seed0; nano::random_pool::generate_block (seed0.bytes.data (), seed0.bytes.size ()); system0.wallet (0)->store.seed (seed0, transaction); ASSERT_NE (seed, seed0); } - scoped_io_thread_name_change scoped_thread_name_io; auto prv = nano::deterministic_key (seed, 0); auto pub (nano::pub_key (prv)); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system0.io_ctx, rpc_config); - nano::rpc rpc (system0.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); boost::property_tree::ptree request; request.put ("action", "wallet_change_seed"); - request.put ("wallet", system0.nodes[0]->wallets.items.begin ()->first.to_string ()); + request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); request.put ("seed", seed.to_string ()); - test_response response (request, rpc.config.port, system0.io_ctx); - system0.deadline_set (5s); - while (response.status == 0) + auto response (wait_response (system0, rpc, request)); { - ASSERT_NO_ERROR (system0.poll ()); - } - ASSERT_EQ (200, response.status); - { - auto transaction (system0.nodes[0]->wallets.tx_begin_read ()); + auto transaction (node->wallets.tx_begin_read ()); nano::raw_key seed0; system0.wallet (0)->store.seed (seed0, transaction); ASSERT_EQ (seed, seed0); } - auto account_text (response.json.get ("last_restored_account")); + auto account_text (response.get ("last_restored_account")); nano::account account; ASSERT_FALSE (account.decode_account (account_text)); ASSERT_TRUE (system0.wallet (0)->exists (account)); ASSERT_EQ (pub, account); - ASSERT_EQ ("1", response.json.get ("restored_count")); + ASSERT_EQ ("1", response.get ("restored_count")); } TEST (rpc, wallet_frontiers) { nano::system system0; auto node = add_ipc_enabled_node (system0); - system0.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system0.io_ctx, rpc_config); - nano::rpc rpc (system0.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + system0.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system0, node); boost::property_tree::ptree request; request.put ("action", "wallet_frontiers"); - request.put ("wallet", system0.nodes[0]->wallets.items.begin ()->first.to_string ()); - test_response response (request, rpc.config.port, system0.io_ctx); - while (response.status == 0) - { - system0.poll (); - } - ASSERT_EQ (200, response.status); - auto & frontiers_node (response.json.get_child ("frontiers")); + request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); + auto response (wait_response (system0, rpc, request)); + auto & frontiers_node (response.get_child ("frontiers")); std::vector frontiers; for (auto i (frontiers_node.begin ()), n (frontiers_node.end ()); i != n; ++i) { frontiers.push_back (nano::account (i->second.get (""))); } ASSERT_EQ (1, frontiers.size ()); - ASSERT_EQ (system0.nodes[0]->latest (nano::genesis_account), frontiers[0]); + ASSERT_EQ (node->latest (nano::dev::genesis->account ()), frontiers[0]); } TEST (rpc, work_validate) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - system.wallet (0)->insert_adhoc (key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); nano::block_hash hash (1); - uint64_t work1 (*node1.work_generate_blocking (hash)); + uint64_t work1 (*node1->work_generate_blocking (hash)); boost::property_tree::ptree request; request.put ("action", "work_validate"); request.put ("hash", hash.to_string ()); request.put ("work", nano::to_string_hex (work1)); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (0, response.json.count ("valid")); - ASSERT_TRUE (response.json.get ("valid_all")); - ASSERT_TRUE (response.json.get ("valid_receive")); - std::string difficulty_text (response.json.get ("difficulty")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (0, response.count ("valid")); + ASSERT_TRUE (response.get ("valid_all")); + ASSERT_TRUE (response.get ("valid_receive")); + std::string difficulty_text (response.get ("difficulty")); uint64_t difficulty; ASSERT_FALSE (nano::from_string_hex (difficulty_text, difficulty)); - ASSERT_GE (difficulty, node1.default_difficulty (nano::work_version::work_1)); - double multiplier (response.json.get ("multiplier")); - ASSERT_NEAR (multiplier, nano::difficulty::to_multiplier (difficulty, node1.default_difficulty (nano::work_version::work_1)), 1e-6); + ASSERT_GE (difficulty, node1->default_difficulty (nano::work_version::work_1)); + double multiplier (response.get ("multiplier")); + ASSERT_NEAR (multiplier, nano::difficulty::to_multiplier (difficulty, node1->default_difficulty (nano::work_version::work_1)), 1e-6); } uint64_t work2 (0); request.put ("work", nano::to_string_hex (work2)); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (0, response.json.count ("valid")); - ASSERT_FALSE (response.json.get ("valid_all")); - ASSERT_FALSE (response.json.get ("valid_receive")); - std::string difficulty_text (response.json.get ("difficulty")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (0, response.count ("valid")); + ASSERT_FALSE (response.get ("valid_all")); + ASSERT_FALSE (response.get ("valid_receive")); + std::string difficulty_text (response.get ("difficulty")); uint64_t difficulty; ASSERT_FALSE (nano::from_string_hex (difficulty_text, difficulty)); - ASSERT_GE (node1.default_difficulty (nano::work_version::work_1), difficulty); - double multiplier (response.json.get ("multiplier")); - ASSERT_NEAR (multiplier, nano::difficulty::to_multiplier (difficulty, node1.default_difficulty (nano::work_version::work_1)), 1e-6); + ASSERT_GE (node1->default_difficulty (nano::work_version::work_1), difficulty); + double multiplier (response.get ("multiplier")); + ASSERT_NEAR (multiplier, nano::difficulty::to_multiplier (difficulty, node1->default_difficulty (nano::work_version::work_1)), 1e-6); } - auto result_difficulty (nano::work_difficulty (nano::work_version::work_1, hash, work1)); - ASSERT_GE (result_difficulty, node1.default_difficulty (nano::work_version::work_1)); + auto result_difficulty (nano::dev::network_params.work.difficulty (nano::work_version::work_1, hash, work1)); + ASSERT_GE (result_difficulty, node1->default_difficulty (nano::work_version::work_1)); request.put ("work", nano::to_string_hex (work1)); request.put ("difficulty", nano::to_string_hex (result_difficulty)); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_TRUE (response.json.get ("valid")); - ASSERT_TRUE (response.json.get ("valid_all")); - ASSERT_TRUE (response.json.get ("valid_receive")); + auto response (wait_response (system, rpc, request)); + ASSERT_TRUE (response.get ("valid")); + ASSERT_TRUE (response.get ("valid_all")); + ASSERT_TRUE (response.get ("valid_receive")); } uint64_t difficulty4 (0xfff0000000000000); request.put ("work", nano::to_string_hex (work1)); request.put ("difficulty", nano::to_string_hex (difficulty4)); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (result_difficulty >= difficulty4, response.json.get ("valid")); - ASSERT_EQ (result_difficulty >= node1.default_difficulty (nano::work_version::work_1), response.json.get ("valid_all")); - ASSERT_EQ (result_difficulty >= node1.network_params.network.publish_thresholds.epoch_2_receive, response.json.get ("valid_all")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (result_difficulty >= difficulty4, response.get ("valid")); + ASSERT_EQ (result_difficulty >= node1->default_difficulty (nano::work_version::work_1), response.get ("valid_all")); + ASSERT_EQ (result_difficulty >= node1->network_params.work.epoch_2_receive, response.get ("valid_all")); } - uint64_t work3 (*node1.work_generate_blocking (hash, difficulty4)); + uint64_t work3 (*node1->work_generate_blocking (hash, difficulty4)); request.put ("work", nano::to_string_hex (work3)); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_TRUE (response.json.get ("valid")); - ASSERT_TRUE (response.json.get ("valid_all")); - ASSERT_TRUE (response.json.get ("valid_receive")); + auto response (wait_response (system, rpc, request)); + ASSERT_TRUE (response.get ("valid")); + ASSERT_TRUE (response.get ("valid_all")); + ASSERT_TRUE (response.get ("valid_receive")); } } @@ -3664,48 +2787,37 @@ TEST (rpc, work_validate_epoch_2) auto node = add_ipc_enabled_node (system); auto epoch1 = system.upgrade_genesis_epoch (*node, nano::epoch::epoch_1); ASSERT_NE (nullptr, epoch1); - ASSERT_EQ (node->network_params.network.publish_thresholds.epoch_2, node->network_params.network.publish_thresholds.base); - auto work = system.work_generate_limited (epoch1->hash (), node->network_params.network.publish_thresholds.epoch_1, node->network_params.network.publish_thresholds.base); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + ASSERT_EQ (node->network_params.work.epoch_2, node->network_params.work.base); + auto work = system.work_generate_limited (epoch1->hash (), node->network_params.work.epoch_1, node->network_params.work.base); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "work_validate"); request.put ("hash", epoch1->hash ().to_string ()); request.put ("work", nano::to_string_hex (work)); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (0, response.json.count ("valid")); - ASSERT_FALSE (response.json.get ("valid_all")); - ASSERT_TRUE (response.json.get ("valid_receive")); - std::string difficulty_text (response.json.get ("difficulty")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (0, response.count ("valid")); + ASSERT_FALSE (response.get ("valid_all")); + ASSERT_TRUE (response.get ("valid_receive")); + std::string difficulty_text (response.get ("difficulty")); uint64_t difficulty{ 0 }; ASSERT_FALSE (nano::from_string_hex (difficulty_text, difficulty)); - double multiplier (response.json.get ("multiplier")); - ASSERT_NEAR (multiplier, nano::difficulty::to_multiplier (difficulty, node->network_params.network.publish_thresholds.epoch_2), 1e-6); + double multiplier (response.get ("multiplier")); + ASSERT_NEAR (multiplier, nano::difficulty::to_multiplier (difficulty, node->network_params.work.epoch_2), 1e-6); }; // After upgrading, the higher difficulty is used to validate and calculate the multiplier - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_2)); - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->renew (); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (0, response.json.count ("valid")); - ASSERT_FALSE (response.json.get ("valid_all")); - ASSERT_TRUE (response.json.get ("valid_receive")); - std::string difficulty_text (response.json.get ("difficulty")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (0, response.count ("valid")); + ASSERT_FALSE (response.get ("valid_all")); + ASSERT_TRUE (response.get ("valid_receive")); + std::string difficulty_text (response.get ("difficulty")); uint64_t difficulty{ 0 }; ASSERT_FALSE (nano::from_string_hex (difficulty_text, difficulty)); - double multiplier (response.json.get ("multiplier")); + double multiplier (response.get ("multiplier")); ASSERT_NEAR (multiplier, nano::difficulty::to_multiplier (difficulty, node->default_difficulty (nano::work_version::work_1)), 1e-6); }; } @@ -3714,28 +2826,19 @@ TEST (rpc, successors) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key; - auto genesis (node->latest (nano::dev_genesis_key.pub)); + auto genesis (node->latest (nano::dev::genesis_key.pub)); ASSERT_FALSE (genesis.is_zero ()); - auto block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 1)); + auto block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 1)); ASSERT_NE (nullptr, block); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "successors"); request.put ("block", genesis.to_string ()); request.put ("count", std::to_string (std::numeric_limits::max ())); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & blocks_node (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + auto & blocks_node (response.get_child ("blocks")); std::vector blocks; for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i) { @@ -3747,10 +2850,8 @@ TEST (rpc, successors) // RPC chain "reverse" option request.put ("action", "chain"); request.put ("reverse", "true"); - test_response response2 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response2.status != 0); - ASSERT_EQ (200, response2.status); - ASSERT_EQ (response.json, response2.json); + auto response2 (wait_response (system, rpc, request, 10s)); + ASSERT_EQ (response, response2); } TEST (rpc, bootstrap_any) @@ -3758,28 +2859,17 @@ TEST (rpc, bootstrap_any) nano::system system0; auto node = add_ipc_enabled_node (system0); nano::system system1 (1); - auto latest (system1.nodes[0]->latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, nano::genesis_account, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system1.nodes[0]->work_generate_blocking (latest)); + auto latest (system1.nodes[0]->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, nano::dev::genesis->account (), 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system1.nodes[0]->work_generate_blocking (latest)); { auto transaction (system1.nodes[0]->store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, system1.nodes[0]->ledger.process (transaction, send).code); } - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system0.io_ctx, rpc_config); - nano::rpc rpc (system0.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system0, node); boost::property_tree::ptree request; request.put ("action", "bootstrap_any"); - test_response response (request, rpc.config.port, system0.io_ctx); - while (response.status == 0) - { - system0.poll (); - } - std::string success (response.json.get ("success")); + auto response (wait_response (system0, rpc, request)); + std::string success (response.get ("success")); ASSERT_TRUE (success.empty ()); } @@ -3787,30 +2877,20 @@ TEST (rpc, republish) { nano::system system; nano::keypair key; - nano::genesis genesis; - auto & node1 = *add_ipc_enabled_node (system); - system.add_node (); - auto latest (node1.latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, key.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - node1.process (send); - nano::open_block open (send.hash (), key.pub, key.pub, key.prv, key.pub, *node1.work_generate_blocking (key.pub)); - ASSERT_EQ (nano::process_result::progress, node1.process (open).code); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + system.add_node (); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + ASSERT_EQ (nano::process_result::progress, node1->process (send).code); + nano::open_block open (send.hash (), key.pub, key.pub, key.prv, key.pub, *node1->work_generate_blocking (key.pub)); + ASSERT_EQ (nano::process_result::progress, node1->process (open).code); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "republish"); request.put ("hash", send.hash ().to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_TIMELY (10s, system.nodes[1]->balance (nano::dev_genesis_key.pub) != nano::genesis_amount); - auto & blocks_node (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + ASSERT_TIMELY (10s, system.nodes[1]->balance (nano::dev::genesis_key.pub) != nano::dev::constants.genesis_amount); + auto & blocks_node (response.get_child ("blocks")); std::vector blocks; for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i) { @@ -3819,34 +2899,29 @@ TEST (rpc, republish) ASSERT_EQ (1, blocks.size ()); ASSERT_EQ (send.hash (), blocks[0]); - request.put ("hash", genesis.hash ().to_string ()); + request.put ("hash", nano::dev::genesis->hash ().to_string ()); request.put ("count", 1); - test_response response1 (request, rpc.config.port, system.io_ctx); - system.deadline_set (5s); - ASSERT_TIMELY (5s, response1.status != 0); - ASSERT_EQ (200, response1.status); - blocks_node = response1.json.get_child ("blocks"); + auto response1 (wait_response (system, rpc, request)); + blocks_node = response1.get_child ("blocks"); blocks.clear (); for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i) { blocks.push_back (nano::block_hash (i->second.get (""))); } ASSERT_EQ (1, blocks.size ()); - ASSERT_EQ (genesis.hash (), blocks[0]); + ASSERT_EQ (nano::dev::genesis->hash (), blocks[0]); request.put ("hash", open.hash ().to_string ()); request.put ("sources", 2); - test_response response2 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response2.status != 0); - ASSERT_EQ (200, response2.status); - blocks_node = response2.json.get_child ("blocks"); + auto response2 (wait_response (system, rpc, request)); + blocks_node = response2.get_child ("blocks"); blocks.clear (); for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i) { blocks.push_back (nano::block_hash (i->second.get (""))); } ASSERT_EQ (3, blocks.size ()); - ASSERT_EQ (genesis.hash (), blocks[0]); + ASSERT_EQ (nano::dev::genesis->hash (), blocks[0]); ASSERT_EQ (send.hash (), blocks[1]); ASSERT_EQ (open.hash (), blocks[2]); } @@ -3863,34 +2938,17 @@ TEST (rpc, deterministic_key) nano::account account0 (system0.wallet (0)->deterministic_insert ()); nano::account account1 (system0.wallet (0)->deterministic_insert ()); nano::account account2 (system0.wallet (0)->deterministic_insert ()); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system0.io_ctx, rpc_config); - nano::rpc rpc (system0.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system0, node); boost::property_tree::ptree request; request.put ("action", "deterministic_key"); request.put ("seed", seed.to_string ()); request.put ("index", "0"); - test_response response0 (request, rpc.config.port, system0.io_ctx); - while (response0.status == 0) - { - system0.poll (); - } - ASSERT_EQ (200, response0.status); - std::string validate_text (response0.json.get ("account")); + auto response0 (wait_response (system0, rpc, request)); + std::string validate_text (response0.get ("account")); ASSERT_EQ (account0.to_account (), validate_text); request.put ("index", "2"); - test_response response1 (request, rpc.config.port, system0.io_ctx); - while (response1.status == 0) - { - system0.poll (); - } - ASSERT_EQ (200, response1.status); - validate_text = response1.json.get ("account"); + auto response1 (wait_response (system0, rpc, request)); + validate_text = response1.get ("account"); ASSERT_NE (account1.to_account (), validate_text); ASSERT_EQ (account2.to_account (), validate_text); } @@ -3899,28 +2957,19 @@ TEST (rpc, accounts_balances) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "accounts_balances"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", nano::dev_genesis_key.pub.to_account ()); + entry.put ("", nano::dev::genesis_key.pub.to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - for (auto & balances : response.json.get_child ("balances")) + auto response (wait_response (system, rpc, request)); + for (auto & balances : response.get_child ("balances")) { std::string account_text (balances.first); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), account_text); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), account_text); std::string balance_text (balances.second.get ("balance")); ASSERT_EQ ("340282366920938463463374607431768211455", balance_text); std::string pending_text (balances.second.get ("pending")); @@ -3928,35 +2977,43 @@ TEST (rpc, accounts_balances) } } +TEST (rpc, accounts_representatives) +{ + nano::system system; + auto node = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node); + boost::property_tree::ptree request; + request.put ("action", "accounts_representatives"); + boost::property_tree::ptree entry; + boost::property_tree::ptree accounts; + entry.put ("", nano::dev::genesis_key.pub.to_account ()); + accounts.push_back (std::make_pair ("", entry)); + request.add_child ("accounts", accounts); + auto response (wait_response (system, rpc, request)); + auto response_representative (response.get_child ("representatives").get (nano::dev::genesis->account ().to_account ())); + ASSERT_EQ (response_representative, nano::dev::genesis->account ().to_account ()); +} + TEST (rpc, accounts_frontiers) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "accounts_frontiers"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", nano::dev_genesis_key.pub.to_account ()); + entry.put ("", nano::dev::genesis_key.pub.to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - for (auto & frontiers : response.json.get_child ("frontiers")) + auto response (wait_response (system, rpc, request)); + for (auto & frontiers : response.get_child ("frontiers")) { std::string account_text (frontiers.first); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), account_text); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), account_text); std::string frontier_text (frontiers.second.get ("")); - ASSERT_EQ (node->latest (nano::genesis_account), frontier_text); + ASSERT_EQ (node->latest (nano::dev::genesis->account ()), nano::block_hash{ frontier_text }); } } @@ -3965,19 +3022,13 @@ TEST (rpc, accounts_pending) nano::system system; auto node = add_ipc_enabled_node (system); nano::keypair key1; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto block1 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key1.pub, 100)); - scoped_io_thread_name_change scoped_thread_name_io; + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto block1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 100)); node->scheduler.flush (); ASSERT_TIMELY (5s, !node->active.active (*block1)); ASSERT_TIMELY (5s, node->ledger.cache.cemented_count == 2 && node->confirmation_height_processor.current ().is_zero () && node->confirmation_height_processor.awaiting_processing_size () == 0); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "accounts_pending"); boost::property_tree::ptree entry; @@ -3987,10 +3038,8 @@ TEST (rpc, accounts_pending) request.add_child ("accounts", peers_l); request.put ("count", "100"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - for (auto & blocks : response.json.get_child ("blocks")) + auto response (wait_response (system, rpc, request)); + for (auto & blocks : response.get_child ("blocks")) { std::string account_text (blocks.first); ASSERT_EQ (key1.pub.to_account (), account_text); @@ -4000,10 +3049,8 @@ TEST (rpc, accounts_pending) } request.put ("sorting", "true"); // Sorting test { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - for (auto & blocks : response.json.get_child ("blocks")) + auto response (wait_response (system, rpc, request)); + for (auto & blocks : response.get_child ("blocks")) { std::string account_text (blocks.first); ASSERT_EQ (key1.pub.to_account (), account_text); @@ -4015,11 +3062,9 @@ TEST (rpc, accounts_pending) } request.put ("threshold", "100"); // Threshold test { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::unordered_map blocks; - for (auto & pending : response.json.get_child ("blocks")) + for (auto & pending : response.get_child ("blocks")) { std::string account_text (pending.first); ASSERT_EQ (key1.pub.to_account (), account_text); @@ -4038,12 +3083,10 @@ TEST (rpc, accounts_pending) } request.put ("source", "true"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::unordered_map amounts; std::unordered_map sources; - for (auto & pending : response.json.get_child ("blocks")) + for (auto & pending : response.get_child ("blocks")) { std::string account_text (pending.first); ASSERT_EQ (key1.pub.to_account (), account_text); @@ -4056,16 +3099,16 @@ TEST (rpc, accounts_pending) } } ASSERT_EQ (amounts[block1->hash ()], 100); - ASSERT_EQ (sources[block1->hash ()], nano::dev_genesis_key.pub); + ASSERT_EQ (sources[block1->hash ()], nano::dev::genesis_key.pub); } check_block_response_count (system, rpc, request, 1); - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); reset_confirmation_height (system.nodes.front ()->store, block1->account ()); - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->renew (); check_block_response_count (system, rpc, request, 0); request.put ("include_only_confirmed", "false"); - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->renew (); check_block_response_count (system, rpc, request, 1); } @@ -4073,28 +3116,19 @@ TEST (rpc, blocks) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "blocks"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", node->latest (nano::genesis_account).to_string ()); + entry.put ("", node->latest (nano::dev::genesis->account ()).to_string ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("hashes", peers_l); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - for (auto & blocks : response.json.get_child ("blocks")) + auto response (wait_response (system, rpc, request)); + for (auto & blocks : response.get_child ("blocks")) { std::string hash_text (blocks.first); - ASSERT_EQ (node->latest (nano::genesis_account).to_string (), hash_text); + ASSERT_EQ (node->latest (nano::dev::genesis->account ()).to_string (), hash_text); std::string blocks_text (blocks.second.get ("")); ASSERT_FALSE (blocks_text.empty ()); } @@ -4103,42 +3137,54 @@ TEST (rpc, blocks) TEST (rpc, wallet_info) { nano::system system; - auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + nano::node_config node_config (nano::get_available_port (), system.logging); + node_config.enable_voting = true; + auto node = add_ipc_enabled_node (system, node_config); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key; system.wallet (0)->insert_adhoc (key.prv); - auto send (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 1)); + + // at first, 1 block and 1 confirmed -- the genesis + ASSERT_EQ (1, node->ledger.cache.block_count); + ASSERT_EQ (1, node->ledger.cache.cemented_count); + + auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::MBAN_ratio)); + // after the send, expect 2 blocks immediately, then 2 confirmed in a timely manner, + // and finally 3 blocks and 3 confirmed after the wallet generates the receive block for this send + ASSERT_EQ (2, node->ledger.cache.block_count); + ASSERT_TIMELY (5s, 2 == node->ledger.cache.cemented_count); + ASSERT_TIMELY (5s, 3 == node->ledger.cache.block_count && 3 == node->ledger.cache.cemented_count); + + // do another send to be able to expect some "pending" down below + auto send2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 1)); + ASSERT_EQ (4, node->ledger.cache.block_count); + nano::account account (system.wallet (0)->deterministic_insert ()); { auto transaction (node->wallets.tx_begin_write ()); system.wallet (0)->store.erase (transaction, account); } account = system.wallet (0)->deterministic_insert (); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "wallet_info"); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string balance_text (response.json.get ("balance")); + auto response (wait_response (system, rpc, request)); + std::string balance_text (response.get ("balance")); ASSERT_EQ ("340282366920938463463374607431768211454", balance_text); - std::string pending_text (response.json.get ("pending")); + std::string pending_text (response.get ("pending")); ASSERT_EQ ("1", pending_text); - std::string count_text (response.json.get ("accounts_count")); + std::string count_text (response.get ("accounts_count")); ASSERT_EQ ("3", count_text); - std::string adhoc_count (response.json.get ("adhoc_count")); + std::string block_count_text (response.get ("accounts_block_count")); + ASSERT_EQ ("4", block_count_text); + std::string cemented_block_count_text (response.get ("accounts_cemented_block_count")); + ASSERT_EQ ("3", cemented_block_count_text); + std::string adhoc_count (response.get ("adhoc_count")); ASSERT_EQ ("2", adhoc_count); - std::string deterministic_count (response.json.get ("deterministic_count")); + std::string deterministic_count (response.get ("deterministic_count")); ASSERT_EQ ("1", deterministic_count); - std::string index_text (response.json.get ("deterministic_index")); + std::string index_text (response.get ("deterministic_index")); ASSERT_EQ ("2", index_text); } @@ -4146,49 +3192,32 @@ TEST (rpc, wallet_balances) { nano::system system0; auto node = add_ipc_enabled_node (system0); - system0.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system0.io_ctx, rpc_config); - nano::rpc rpc (system0.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + system0.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system0, node); boost::property_tree::ptree request; request.put ("action", "wallet_balances"); - request.put ("wallet", system0.nodes[0]->wallets.items.begin ()->first.to_string ()); - test_response response (request, rpc.config.port, system0.io_ctx); - while (response.status == 0) - { - system0.poll (); - } - ASSERT_EQ (200, response.status); - for (auto & balances : response.json.get_child ("balances")) + request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); + auto response (wait_response (system0, rpc, request)); + for (auto & balances : response.get_child ("balances")) { std::string account_text (balances.first); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), account_text); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), account_text); std::string balance_text (balances.second.get ("balance")); ASSERT_EQ ("340282366920938463463374607431768211455", balance_text); std::string pending_text (balances.second.get ("pending")); ASSERT_EQ ("0", pending_text); } nano::keypair key; - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); system0.wallet (0)->insert_adhoc (key.prv); - auto send (system0.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, 1)); - scoped_thread_name_io.renew (); + auto send (system0.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, 1)); + rpc_ctx->io_scope->renew (); request.put ("threshold", "2"); - test_response response1 (request, rpc.config.port, system0.io_ctx); - while (response1.status == 0) - { - system0.poll (); - } - ASSERT_EQ (200, response1.status); - for (auto & balances : response1.json.get_child ("balances")) + auto response1 (wait_response (system0, rpc, request)); + for (auto & balances : response1.get_child ("balances")) { std::string account_text (balances.first); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), account_text); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), account_text); std::string balance_text (balances.second.get ("balance")); ASSERT_EQ ("340282366920938463463374607431768211454", balance_text); std::string pending_text (balances.second.get ("pending")); @@ -4201,27 +3230,19 @@ TEST (rpc, pending_exists) nano::system system; auto node = add_ipc_enabled_node (system); nano::keypair key1; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto hash0 (node->latest (nano::genesis_account)); - auto block1 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key1.pub, 100)); - scoped_io_thread_name_change scoped_thread_name_io; + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto hash0 (node->latest (nano::dev::genesis->account ())); + auto block1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 100)); node->scheduler.flush (); ASSERT_TIMELY (5s, !node->active.active (*block1)); ASSERT_TIMELY (5s, node->ledger.cache.cemented_count == 2 && node->confirmation_height_processor.current ().is_zero () && node->confirmation_height_processor.awaiting_processing_size () == 0); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; - auto pending_exists = [&system, &request, &rpc] (const char * exists_a) { - test_response response0 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response0.status != 0); - ASSERT_EQ (200, response0.status); - std::string exists_text (response0.json.get ("exists")); + auto pending_exists = [&system, &request, rpc = rpc] (char const * exists_a) { + auto response0 (wait_response (system, rpc, request)); + std::string exists_text (response0.get ("exists")); ASSERT_EQ (exists_a, exists_text); }; @@ -4229,17 +3250,17 @@ TEST (rpc, pending_exists) request.put ("hash", hash0.to_string ()); pending_exists ("0"); - node->store.pending_exists (node->store.tx_begin_read (), nano::pending_key (nano::dev_genesis_key.pub, block1->hash ())); + node->store.pending.exists (node->store.tx_begin_read (), nano::pending_key (nano::dev::genesis_key.pub, block1->hash ())); request.put ("hash", block1->hash ().to_string ()); pending_exists ("1"); pending_exists ("1"); - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); reset_confirmation_height (node->store, block1->account ()); - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->renew (); pending_exists ("0"); request.put ("include_only_confirmed", "false"); - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->renew (); pending_exists ("1"); } @@ -4248,11 +3269,10 @@ TEST (rpc, wallet_pending) nano::system system0; auto node = add_ipc_enabled_node (system0); nano::keypair key1; - system0.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system0.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system0.wallet (0)->insert_adhoc (key1.prv); auto iterations (0); - auto block1 (system0.wallet (0)->send_action (nano::dev_genesis_key.pub, key1.pub, 100)); - scoped_io_thread_name_change scoped_thread_name_io; + auto block1 (system0.wallet (0)->send_action (nano::dev::genesis_key.pub, key1.pub, 100)); node->scheduler.flush (); while (node->active.active (*block1) || node->ledger.cache.cemented_count < 2 || !node->confirmation_height_processor.current ().is_zero () || node->confirmation_height_processor.awaiting_processing_size () != 0) { @@ -4260,25 +3280,15 @@ TEST (rpc, wallet_pending) ++iterations; ASSERT_LT (iterations, 200); } - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system0.io_ctx, rpc_config); - nano::rpc rpc (system0.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + + auto [rpc, rpc_ctx] = add_rpc (system0, node); boost::property_tree::ptree request; request.put ("action", "wallet_pending"); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); request.put ("count", "100"); - test_response response (request, rpc.config.port, system0.io_ctx); - while (response.status == 0) - { - system0.poll (); - } - ASSERT_EQ (200, response.status); - ASSERT_EQ (1, response.json.get_child ("blocks").size ()); - for (auto & pending : response.json.get_child ("blocks")) + auto response (wait_response (system0, rpc, request)); + ASSERT_EQ (1, response.get_child ("blocks").size ()); + for (auto & pending : response.get_child ("blocks")) { std::string account_text (pending.first); ASSERT_EQ (key1.pub.to_account (), account_text); @@ -4286,15 +3296,10 @@ TEST (rpc, wallet_pending) ASSERT_EQ (block1->hash (), hash1); } request.put ("threshold", "100"); // Threshold test - test_response response0 (request, rpc.config.port, system0.io_ctx); - while (response0.status == 0) - { - system0.poll (); - } - ASSERT_EQ (200, response0.status); + auto response0 (wait_response (system0, rpc, request)); std::unordered_map blocks; - ASSERT_EQ (1, response0.json.get_child ("blocks").size ()); - for (auto & pending : response0.json.get_child ("blocks")) + ASSERT_EQ (1, response0.get_child ("blocks").size ()); + for (auto & pending : response0.get_child ("blocks")) { std::string account_text (pending.first); ASSERT_EQ (key1.pub.to_account (), account_text); @@ -4313,27 +3318,17 @@ TEST (rpc, wallet_pending) } ASSERT_EQ (blocks[block1->hash ()], 100); request.put ("threshold", "101"); - test_response response1 (request, rpc.config.port, system0.io_ctx); - while (response1.status == 0) - { - system0.poll (); - } - ASSERT_EQ (200, response1.status); - auto & pending1 (response1.json.get_child ("blocks")); + auto response1 (wait_response (system0, rpc, request)); + auto & pending1 (response1.get_child ("blocks")); ASSERT_EQ (0, pending1.size ()); request.put ("threshold", "0"); request.put ("source", "true"); request.put ("min_version", "true"); - test_response response2 (request, rpc.config.port, system0.io_ctx); - while (response2.status == 0) - { - system0.poll (); - } - ASSERT_EQ (200, response2.status); + auto response2 (wait_response (system0, rpc, request)); std::unordered_map amounts; std::unordered_map sources; - ASSERT_EQ (1, response0.json.get_child ("blocks").size ()); - for (auto & pending : response2.json.get_child ("blocks")) + ASSERT_EQ (1, response2.get_child ("blocks").size ()); + for (auto & pending : response2.get_child ("blocks")) { std::string account_text (pending.first); ASSERT_EQ (key1.pub.to_account (), account_text); @@ -4347,24 +3342,15 @@ TEST (rpc, wallet_pending) } } ASSERT_EQ (amounts[block1->hash ()], 100); - ASSERT_EQ (sources[block1->hash ()], nano::dev_genesis_key.pub); + ASSERT_EQ (sources[block1->hash ()], nano::dev::genesis_key.pub); check_block_response_count (system0, rpc, request, 1); - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); reset_confirmation_height (system0.nodes.front ()->store, block1->account ()); - scoped_thread_name_io.renew (); - { - test_response response (request, rpc.config.port, system0.io_ctx); - system0.deadline_set (5s); - while (response.status == 0) - { - ASSERT_NO_ERROR (system0.poll ()); - } - ASSERT_EQ (200, response.status); - ASSERT_EQ (0, response.json.get_child ("blocks").size ()); - } + rpc_ctx->io_scope->renew (); + check_block_response_count (system0, rpc, request, 0); request.put ("include_only_confirmed", "false"); - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->renew (); check_block_response_count (system0, rpc, request, 1); } @@ -4372,20 +3358,11 @@ TEST (rpc, receive_minimum) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receive_minimum"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string amount (response.json.get ("amount")); + auto response (wait_response (system, rpc, request)); + std::string amount (response.get ("amount")); ASSERT_EQ (node->config.receive_minimum.to_string_dec (), amount); } @@ -4393,22 +3370,13 @@ TEST (rpc, receive_minimum_set) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receive_minimum_set"); request.put ("amount", "100"); ASSERT_NE (node->config.receive_minimum.to_string_dec (), "100"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string success (response.json.get ("success")); + auto response (wait_response (system, rpc, request)); + std::string success (response.get ("success")); ASSERT_TRUE (success.empty ()); ASSERT_EQ (node->config.receive_minimum.to_string_dec (), "100"); } @@ -4417,27 +3385,18 @@ TEST (rpc, work_get) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - system.wallet (0)->work_cache_blocking (nano::dev_genesis_key.pub, node->latest (nano::dev_genesis_key.pub)); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + system.wallet (0)->work_cache_blocking (nano::dev::genesis_key.pub, node->latest (nano::dev::genesis_key.pub)); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "work_get"); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string work_text (response.json.get ("work")); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); + auto response (wait_response (system, rpc, request)); + std::string work_text (response.get ("work")); uint64_t work (1); auto transaction (node->wallets.tx_begin_read ()); - node->wallets.items.begin ()->second->store.work_get (transaction, nano::genesis_account, work); + node->wallets.items.begin ()->second->store.work_get (transaction, nano::dev::genesis->account (), work); ASSERT_EQ (nano::to_string_hex (work), work_text); } @@ -4445,30 +3404,21 @@ TEST (rpc, wallet_work_get) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - system.wallet (0)->work_cache_blocking (nano::dev_genesis_key.pub, node->latest (nano::dev_genesis_key.pub)); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + system.wallet (0)->work_cache_blocking (nano::dev::genesis_key.pub, node->latest (nano::dev::genesis_key.pub)); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "wallet_work_get"); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); auto transaction (node->wallets.tx_begin_read ()); - for (auto & works : response.json.get_child ("works")) + for (auto & works : response.get_child ("works")) { std::string account_text (works.first); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), account_text); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), account_text); std::string work_text (works.second.get ("")); uint64_t work (1); - node->wallets.items.begin ()->second->store.work_get (transaction, nano::genesis_account, work); + node->wallets.items.begin ()->second->store.work_get (transaction, nano::dev::genesis->account (), work); ASSERT_EQ (nano::to_string_hex (work), work_text); } } @@ -4477,29 +3427,20 @@ TEST (rpc, work_set) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); uint64_t work0 (100); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); boost::property_tree::ptree request; request.put ("action", "work_set"); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); request.put ("work", nano::to_string_hex (work0)); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string success (response.json.get ("success")); + auto response (wait_response (system, rpc, request)); + std::string success (response.get ("success")); ASSERT_TRUE (success.empty ()); uint64_t work1 (1); auto transaction (node->wallets.tx_begin_read ()); - node->wallets.items.begin ()->second->store.work_get (transaction, nano::genesis_account, work1); + node->wallets.items.begin ()->second->store.work_get (transaction, nano::dev::genesis->account (), work1); ASSERT_EQ (work1, work0); } @@ -4507,64 +3448,45 @@ TEST (rpc, search_pending_all) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto latest (node->latest (nano::dev_genesis_key.pub)); - nano::send_block block (latest, nano::dev_genesis_key.pub, nano::genesis_amount - node->config.receive_minimum.number (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node->work_generate_blocking (latest)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto latest (node->latest (nano::dev::genesis_key.pub)); + nano::send_block block (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - node->config.receive_minimum.number (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (latest)); { auto transaction (node->store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, block).code); } - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "search_pending_all"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_TIMELY (10s, node->balance (nano::dev_genesis_key.pub) == nano::genesis_amount); + auto response (wait_response (system, rpc, request)); + ASSERT_TIMELY (10s, node->balance (nano::dev::genesis_key.pub) == nano::dev::constants.genesis_amount); } TEST (rpc, wallet_republish) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - nano::genesis genesis; + auto node1 = add_ipc_enabled_node (system); nano::keypair key; - while (key.pub < nano::dev_genesis_key.pub) + while (key.pub < nano::dev::genesis_key.pub) { nano::keypair key1; key.pub = key1.pub; key.prv = key1.prv; } - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - auto latest (node1.latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, key.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - node1.process (send); - nano::open_block open (send.hash (), key.pub, key.pub, key.prv, key.pub, *node1.work_generate_blocking (key.pub)); - ASSERT_EQ (nano::process_result::progress, node1.process (open).code); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + ASSERT_EQ (nano::process_result::progress, node1->process (send).code); + nano::open_block open (send.hash (), key.pub, key.pub, key.prv, key.pub, *node1->work_generate_blocking (key.pub)); + ASSERT_EQ (nano::process_result::progress, node1->process (open).code); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "wallet_republish"); - request.put ("wallet", node1.wallets.items.begin ()->first.to_string ()); + request.put ("wallet", node1->wallets.items.begin ()->first.to_string ()); request.put ("count", 1); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & blocks_node (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + auto & blocks_node (response.get_child ("blocks")); std::vector blocks; for (auto i (blocks_node.begin ()), n (blocks_node.end ()); i != n; ++i) { @@ -4578,67 +3500,142 @@ TEST (rpc, wallet_republish) TEST (rpc, delegators) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); + auto node1 = add_ipc_enabled_node (system); nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - auto latest (node1.latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, key.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - node1.process (send); - nano::open_block open (send.hash (), nano::dev_genesis_key.pub, key.pub, key.prv, key.pub, *node1.work_generate_blocking (key.pub)); - ASSERT_EQ (nano::process_result::progress, node1.process (open).code); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + ASSERT_EQ (nano::process_result::progress, node1->process (send).code); + nano::open_block open (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *node1->work_generate_blocking (key.pub)); + ASSERT_EQ (nano::process_result::progress, node1->process (open).code); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "delegators"); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & delegators_node (response.json.get_child ("delegators")); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); + auto response (wait_response (system, rpc, request)); + auto & delegators_node (response.get_child ("delegators")); + boost::property_tree::ptree delegators; + for (auto i (delegators_node.begin ()), n (delegators_node.end ()); i != n; ++i) + { + delegators.put ((i->first), (i->second.get (""))); + } + ASSERT_EQ (2, delegators.size ()); + ASSERT_EQ ("100", delegators.get (nano::dev::genesis_key.pub.to_account ())); + ASSERT_EQ ("340282366920938463463374607431768211355", delegators.get (key.pub.to_account ())); +} + +TEST (rpc, delegators_parameters) +{ + nano::system system; + auto node1 = add_ipc_enabled_node (system); + nano::keypair key; + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + ASSERT_EQ (nano::process_result::progress, node1->process (send).code); + nano::open_block open (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *node1->work_generate_blocking (key.pub)); + ASSERT_EQ (nano::process_result::progress, node1->process (open).code); + + auto [rpc, rpc_ctx] = add_rpc (system, node1); + // Test with "count" = 2 + boost::property_tree::ptree request; + request.put ("action", "delegators"); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); + request.put ("count", 2); + auto response (wait_response (system, rpc, request)); + auto & delegators_node (response.get_child ("delegators")); boost::property_tree::ptree delegators; for (auto i (delegators_node.begin ()), n (delegators_node.end ()); i != n; ++i) { delegators.put ((i->first), (i->second.get (""))); } ASSERT_EQ (2, delegators.size ()); - ASSERT_EQ ("100", delegators.get (nano::dev_genesis_key.pub.to_account ())); + ASSERT_EQ ("100", delegators.get (nano::dev::genesis_key.pub.to_account ())); ASSERT_EQ ("340282366920938463463374607431768211355", delegators.get (key.pub.to_account ())); + + // Test with "count" = 1 + request.put ("count", 1); + auto response2 (wait_response (system, rpc, request)); + auto & delegators_node2 (response2.get_child ("delegators")); + boost::property_tree::ptree delegators2; + for (auto i (delegators_node2.begin ()), n (delegators_node2.end ()); i != n; ++i) + { + delegators2.put ((i->first), (i->second.get (""))); + } + ASSERT_EQ (1, delegators2.size ()); + // What is first in ledger by public key? + if (nano::dev::genesis_key.pub.number () < key.pub.number ()) + { + ASSERT_EQ ("100", delegators2.get (nano::dev::genesis_key.pub.to_account ())); + } + else + { + ASSERT_EQ ("340282366920938463463374607431768211355", delegators2.get (key.pub.to_account ())); + } + + // Test with "threshold" + request.put ("count", 1024); + request.put ("threshold", 101); // higher than remaining genesis balance + auto response3 (wait_response (system, rpc, request)); + auto & delegators_node3 (response3.get_child ("delegators")); + boost::property_tree::ptree delegators3; + for (auto i (delegators_node3.begin ()), n (delegators_node3.end ()); i != n; ++i) + { + delegators3.put ((i->first), (i->second.get (""))); + } + ASSERT_EQ (1, delegators3.size ()); + ASSERT_EQ ("340282366920938463463374607431768211355", delegators3.get (key.pub.to_account ())); + + // Test with "start" before last account + request.put ("threshold", 0); + auto last_account (key.pub); + if (nano::dev::genesis_key.pub.number () > key.pub.number ()) + { + last_account = nano::dev::genesis_key.pub; + } + request.put ("start", nano::account (last_account.number () - 1).to_account ()); + + auto response4 (wait_response (system, rpc, request)); + auto & delegators_node4 (response4.get_child ("delegators")); + boost::property_tree::ptree delegators4; + for (auto i (delegators_node4.begin ()), n (delegators_node4.end ()); i != n; ++i) + { + delegators4.put ((i->first), (i->second.get (""))); + } + ASSERT_EQ (1, delegators4.size ()); + boost::optional balance (delegators4.get_optional (last_account.to_account ())); + ASSERT_TRUE (balance.is_initialized ()); + + // Test with "start" equal to last account + request.put ("start", last_account.to_account ()); + auto response5 (wait_response (system, rpc, request)); + auto & delegators_node5 (response5.get_child ("delegators")); + boost::property_tree::ptree delegators5; + for (auto i (delegators_node5.begin ()), n (delegators_node5.end ()); i != n; ++i) + { + delegators5.put ((i->first), (i->second.get (""))); + } + ASSERT_EQ (0, delegators5.size ()); } TEST (rpc, delegators_count) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); + auto node1 = add_ipc_enabled_node (system); nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - auto latest (node1.latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, key.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - node1.process (send); - nano::open_block open (send.hash (), nano::dev_genesis_key.pub, key.pub, key.prv, key.pub, *node1.work_generate_blocking (key.pub)); - ASSERT_EQ (nano::process_result::progress, node1.process (open).code); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + ASSERT_EQ (nano::process_result::progress, node1->process (send).code); + nano::open_block open (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *node1->work_generate_blocking (key.pub)); + ASSERT_EQ (nano::process_result::progress, node1->process (open).code); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "delegators_count"); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string count (response.json.get ("count")); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); + auto response (wait_response (system, rpc, request)); + std::string count (response.get ("count")); ASSERT_EQ ("2", count); } @@ -4646,17 +3643,9 @@ TEST (rpc, account_info) { nano::system system; nano::keypair key; - nano::genesis genesis; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "account_info"); @@ -4664,55 +3653,51 @@ TEST (rpc, account_info) // Test for a non existing account { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); + auto response (wait_response (system, rpc, request)); - auto error (response.json.get_optional ("error")); + auto error (response.get_optional ("error")); ASSERT_TRUE (error.is_initialized ()); ASSERT_EQ (error.get (), std::error_code (nano::error_common::account_not_found).message ()); } - scoped_thread_name_io.reset (); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + rpc_ctx->io_scope->reset (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - auto latest (node1.latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, key.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - node1.process (send); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + ASSERT_EQ (nano::process_result::progress, node1->process (send).code); auto time (nano::seconds_since_epoch ()); { - auto transaction = node1.store.tx_begin_write (); - node1.store.confirmation_height_put (transaction, nano::dev_genesis_key.pub, { 1, genesis.hash () }); + auto transaction = node1->store.tx_begin_write (); + node1->store.confirmation_height.put (transaction, nano::dev::genesis_key.pub, { 1, nano::dev::genesis->hash () }); } - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->renew (); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - - ASSERT_EQ (200, response.status); - std::string frontier (response.json.get ("frontier")); + auto response (wait_response (system, rpc, request)); + std::string frontier (response.get ("frontier")); ASSERT_EQ (send.hash ().to_string (), frontier); - std::string open_block (response.json.get ("open_block")); - ASSERT_EQ (genesis.hash ().to_string (), open_block); - std::string representative_block (response.json.get ("representative_block")); - ASSERT_EQ (genesis.hash ().to_string (), representative_block); - std::string balance (response.json.get ("balance")); + std::string open_block (response.get ("open_block")); + ASSERT_EQ (nano::dev::genesis->hash ().to_string (), open_block); + std::string representative_block (response.get ("representative_block")); + ASSERT_EQ (nano::dev::genesis->hash ().to_string (), representative_block); + std::string balance (response.get ("balance")); ASSERT_EQ ("100", balance); - std::string modified_timestamp (response.json.get ("modified_timestamp")); + std::string modified_timestamp (response.get ("modified_timestamp")); ASSERT_LT (std::abs ((long)time - stol (modified_timestamp)), 5); - std::string block_count (response.json.get ("block_count")); + std::string block_count (response.get ("block_count")); ASSERT_EQ ("2", block_count); - std::string confirmation_height (response.json.get ("confirmation_height")); + std::string confirmation_height (response.get ("confirmation_height")); ASSERT_EQ ("1", confirmation_height); - std::string confirmation_height_frontier (response.json.get ("confirmation_height_frontier")); - ASSERT_EQ (genesis.hash ().to_string (), confirmation_height_frontier); - ASSERT_EQ (0, response.json.get ("account_version")); - boost::optional weight (response.json.get_optional ("weight")); + std::string confirmation_height_frontier (response.get ("confirmation_height_frontier")); + ASSERT_EQ (nano::dev::genesis->hash ().to_string (), confirmation_height_frontier); + ASSERT_EQ (0, response.get ("account_version")); + boost::optional weight (response.get_optional ("weight")); ASSERT_FALSE (weight.is_initialized ()); - boost::optional pending (response.json.get_optional ("pending")); + boost::optional pending (response.get_optional ("pending")); ASSERT_FALSE (pending.is_initialized ()); - boost::optional representative (response.json.get_optional ("representative")); + boost::optional representative (response.get_optional ("representative")); ASSERT_FALSE (representative.is_initialized ()); } @@ -4721,95 +3706,90 @@ TEST (rpc, account_info) request.put ("pending", "1"); request.put ("representative", "1"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - std::string weight2 (response.json.get ("weight")); + auto response (wait_response (system, rpc, request)); + std::string weight2 (response.get ("weight")); ASSERT_EQ ("100", weight2); - std::string pending2 (response.json.get ("pending")); + std::string pending2 (response.get ("pending")); ASSERT_EQ ("0", pending2); - std::string representative2 (response.json.get ("representative")); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), representative2); + std::string representative2 (response.get ("representative")); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), representative2); } // Test for confirmed only blocks - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); nano::keypair key1; { - latest = node1.latest (nano::dev_genesis_key.pub); - nano::send_block send1 (latest, key1.pub, 50, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - node1.process (send1); - nano::send_block send2 (send1.hash (), key1.pub, 25, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (send1.hash ())); - node1.process (send2); + latest = node1->latest (nano::dev::genesis_key.pub); + nano::send_block send1 (latest, key1.pub, 50, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + ASSERT_EQ (nano::process_result::progress, node1->process (send1).code); + nano::send_block send2 (send1.hash (), key1.pub, 25, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (send1.hash ())); + ASSERT_EQ (nano::process_result::progress, node1->process (send2).code); - nano::state_block state_change (nano::dev_genesis_key.pub, send2.hash (), key1.pub, 25, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (send2.hash ())); - node1.process (state_change); + nano::state_block state_change (nano::dev::genesis_key.pub, send2.hash (), key1.pub, 25, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (send2.hash ())); + ASSERT_EQ (nano::process_result::progress, node1->process (state_change).code); - nano::open_block open (send1.hash (), nano::dev_genesis_key.pub, key1.pub, key1.prv, key1.pub, *node1.work_generate_blocking (key1.pub)); - node1.process (open); + nano::open_block open (send1.hash (), nano::dev::genesis_key.pub, key1.pub, key1.prv, key1.pub, *node1->work_generate_blocking (key1.pub)); + ASSERT_EQ (nano::process_result::progress, node1->process (open).code); } - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->renew (); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - std::string balance (response.json.get ("balance")); + auto response (wait_response (system, rpc, request)); + std::string balance (response.get ("balance")); ASSERT_EQ ("25", balance); } request.put ("include_confirmed", true); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - auto balance (response.json.get ("balance")); + auto response (wait_response (system, rpc, request)); + auto balance (response.get ("balance")); ASSERT_EQ ("25", balance); - auto confirmed_balance (response.json.get ("confirmed_balance")); + auto confirmed_balance (response.get ("confirmed_balance")); ASSERT_EQ ("340282366920938463463374607431768211455", confirmed_balance); - auto representative (response.json.get ("representative")); + auto representative (response.get ("representative")); ASSERT_EQ (representative, key1.pub.to_account ()); - auto confirmed_representative (response.json.get ("confirmed_representative")); - ASSERT_EQ (confirmed_representative, nano::dev_genesis_key.pub.to_account ()); + auto confirmed_representative (response.get ("confirmed_representative")); + ASSERT_EQ (confirmed_representative, nano::dev::genesis_key.pub.to_account ()); - auto confirmed_frontier (response.json.get ("confirmed_frontier")); - ASSERT_EQ (nano::genesis_hash.to_string (), confirmed_frontier); + auto confirmed_frontier (response.get ("confirmed_frontier")); + ASSERT_EQ (nano::dev::genesis->hash ().to_string (), confirmed_frontier); - auto confirmed_height (response.json.get ("confirmed_height")); + auto confirmed_height (response.get ("confirmed_height")); ASSERT_EQ (1, confirmed_height); } request.put ("account", key1.pub.to_account ()); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - std::string pending (response.json.get ("pending")); + auto response (wait_response (system, rpc, request)); + std::string pending (response.get ("pending")); ASSERT_EQ ("25", pending); - std::string confirmed_pending (response.json.get ("confirmed_pending")); + std::string confirmed_pending (response.get ("confirmed_pending")); ASSERT_EQ ("0", confirmed_pending); } request.put ("include_confirmed", false); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - std::string pending (response.json.get ("pending")); + auto response (wait_response (system, rpc, request)); + std::string pending (response.get ("pending")); ASSERT_EQ ("25", pending); // These fields shouldn't exist - auto confirmed_balance (response.json.get_optional ("confirmed_balance")); + auto confirmed_balance (response.get_optional ("confirmed_balance")); ASSERT_FALSE (confirmed_balance.is_initialized ()); - auto confirmed_pending (response.json.get_optional ("confirmed_pending")); + auto confirmed_pending (response.get_optional ("confirmed_pending")); ASSERT_FALSE (confirmed_pending.is_initialized ()); - auto confirmed_representative (response.json.get_optional ("confirmed_representative")); + auto confirmed_representative (response.get_optional ("confirmed_representative")); ASSERT_FALSE (confirmed_representative.is_initialized ()); - auto confirmed_frontier (response.json.get_optional ("confirmed_frontier")); + auto confirmed_frontier (response.get_optional ("confirmed_frontier")); ASSERT_FALSE (confirmed_frontier.is_initialized ()); - auto confirmed_height (response.json.get_optional ("confirmed_height")); + auto confirmed_height (response.get_optional ("confirmed_height")); ASSERT_FALSE (confirmed_height.is_initialized ()); } } @@ -4817,35 +3797,26 @@ TEST (rpc, account_info) /** Make sure we can use json block literals instead of string as input */ TEST (rpc, json_block_input) { - nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - nano::keypair key; - system.wallet (0)->insert_adhoc (key.prv); - nano::state_block send (nano::genesis_account, node1.latest (nano::dev_genesis_key.pub), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + nano::system system; + auto node1 = add_ipc_enabled_node (system); + nano::keypair key; + system.wallet (0)->insert_adhoc (key.prv); + nano::state_block send (nano::dev::genesis->account (), node1->latest (nano::dev::genesis_key.pub), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "sign"); request.put ("json_block", "true"); std::string wallet; - node1.wallets.items.begin ()->first.encode_hex (wallet); + node1->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("account", key.pub.to_account ()); boost::property_tree::ptree json; send.serialize_json (json); request.add_child ("block", json); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request, 10s)); bool json_error{ false }; - nano::state_block block (json_error, response.json.get_child ("block")); + nano::state_block block (json_error, response.get_child ("block")); ASSERT_FALSE (json_error); ASSERT_FALSE (nano::validate_message (key.pub, send.hash (), block.block_signature ())); @@ -4857,32 +3828,21 @@ TEST (rpc, json_block_input) TEST (rpc, json_block_output) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); + auto node1 = add_ipc_enabled_node (system); nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - system.wallet (0)->insert_adhoc (key.prv); - auto latest (node1.latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, key.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - node1.process (send); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + ASSERT_EQ (nano::process_result::progress, node1->process (send).code); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "block_info"); request.put ("json_block", "true"); request.put ("hash", send.hash ().to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); // Make sure contents contains a valid JSON subtree instread of stringified json bool json_error{ false }; - nano::send_block send_from_json (json_error, response.json.get_child ("contents")); + nano::send_block send_from_json (json_error, response.get_child ("contents")); ASSERT_FALSE (json_error); } @@ -4890,23 +3850,16 @@ TEST (rpc, blocks_info) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); - auto check_blocks = [node] (test_response & response) { - for (auto & blocks : response.json.get_child ("blocks")) + auto [rpc, rpc_ctx] = add_rpc (system, node); + auto check_blocks = [node] (boost::property_tree::ptree & response) { + for (auto & blocks : response.get_child ("blocks")) { std::string hash_text (blocks.first); - ASSERT_EQ (node->latest (nano::genesis_account).to_string (), hash_text); + ASSERT_EQ (node->latest (nano::dev::genesis->account ()).to_string (), hash_text); std::string account_text (blocks.second.get ("block_account")); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), account_text); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), account_text); std::string amount_text (blocks.second.get ("amount")); - ASSERT_EQ (nano::genesis_amount.convert_to (), amount_text); + ASSERT_EQ (nano::dev::constants.genesis_amount.convert_to (), amount_text); std::string blocks_text (blocks.second.get ("contents")); ASSERT_FALSE (blocks_text.empty ()); boost::optional pending (blocks.second.get_optional ("pending")); @@ -4914,21 +3867,21 @@ TEST (rpc, blocks_info) boost::optional source (blocks.second.get_optional ("source_account")); ASSERT_FALSE (source.is_initialized ()); std::string balance_text (blocks.second.get ("balance")); - ASSERT_EQ (nano::genesis_amount.convert_to (), balance_text); + ASSERT_EQ (nano::dev::constants.genesis_amount.convert_to (), balance_text); ASSERT_TRUE (blocks.second.get ("confirmed")); // Genesis block is confirmed by default + std::string successor_text (blocks.second.get ("successor")); + ASSERT_EQ (nano::block_hash (0).to_string (), successor_text); // Genesis block doesn't have successor yet } }; boost::property_tree::ptree request; request.put ("action", "blocks_info"); boost::property_tree::ptree entry; boost::property_tree::ptree hashes; - entry.put ("", node->latest (nano::genesis_account).to_string ()); + entry.put ("", node->latest (nano::dev::genesis->account ()).to_string ()); hashes.push_back (std::make_pair ("", entry)); request.add_child ("hashes", hashes); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); check_blocks (response); } std::string random_hash = nano::block_hash ().to_string (); @@ -4937,28 +3890,22 @@ TEST (rpc, blocks_info) request.erase ("hashes"); request.add_child ("hashes", hashes); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_blocks::not_found).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (std::error_code (nano::error_blocks::not_found).message (), response.get ("error")); } request.put ("include_not_found", "true"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); check_blocks (response); - auto & blocks_not_found (response.json.get_child ("blocks_not_found")); + auto & blocks_not_found (response.get_child ("blocks_not_found")); ASSERT_EQ (1, blocks_not_found.size ()); ASSERT_EQ (random_hash, blocks_not_found.begin ()->second.get ("")); } request.put ("source", "true"); request.put ("pending", "1"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - for (auto & blocks : response.json.get_child ("blocks")) + auto response (wait_response (system, rpc, request)); + for (auto & blocks : response.get_child ("blocks")) { std::string source (blocks.second.get ("source_account")); ASSERT_EQ ("0", source); @@ -4971,24 +3918,17 @@ TEST (rpc, blocks_info) TEST (rpc, blocks_info_subtype) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); + auto node1 = add_ipc_enabled_node (system); nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - auto send (system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, nano::MBAN_ratio)); + auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, nano::MBAN_ratio)); ASSERT_NE (nullptr, send); auto receive (system.wallet (0)->receive_action (send->hash (), key.pub, nano::MBAN_ratio, send->link ().as_account ())); ASSERT_NE (nullptr, receive); - auto change (system.wallet (0)->change_action (nano::dev_genesis_key.pub, key.pub)); + auto change (system.wallet (0)->change_action (nano::dev::genesis_key.pub, key.pub)); ASSERT_NE (nullptr, change); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "blocks_info"); boost::property_tree::ptree hashes; @@ -5000,9 +3940,8 @@ TEST (rpc, blocks_info_subtype) entry.put ("", change->hash ().to_string ()); hashes.push_back (std::make_pair ("", entry)); request.add_child ("hashes", hashes); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - auto & blocks (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + auto & blocks (response.get_child ("blocks")); ASSERT_EQ (3, blocks.size ()); auto send_subtype (blocks.get_child (send->hash ().to_string ()).get ("subtype")); ASSERT_EQ (send_subtype, "send"); @@ -5010,149 +3949,147 @@ TEST (rpc, blocks_info_subtype) ASSERT_EQ (receive_subtype, "receive"); auto change_subtype (blocks.get_child (change->hash ().to_string ()).get ("subtype")); ASSERT_EQ (change_subtype, "change"); + // Successor fields + auto send_successor (blocks.get_child (send->hash ().to_string ()).get ("successor")); + ASSERT_EQ (send_successor, receive->hash ().to_string ()); + auto receive_successor (blocks.get_child (receive->hash ().to_string ()).get ("successor")); + ASSERT_EQ (receive_successor, change->hash ().to_string ()); + auto change_successor (blocks.get_child (change->hash ().to_string ()).get ("successor")); + ASSERT_EQ (change_successor, nano::block_hash (0).to_string ()); // Change block doesn't have successor yet +} + +TEST (rpc, block_info_successor) +{ + nano::system system; + auto node1 = add_ipc_enabled_node (system); + nano::keypair key; + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + ASSERT_EQ (nano::process_result::progress, node1->process (send).code); + auto [rpc, rpc_ctx] = add_rpc (system, node1); + boost::property_tree::ptree request; + request.put ("action", "block_info"); + request.put ("hash", latest.to_string ()); + auto response (wait_response (system, rpc, request)); + + // Make sure send block is successor of genesis + std::string successor_text (response.get ("successor")); + ASSERT_EQ (successor_text, send.hash ().to_string ()); + std::string account_text (response.get ("block_account")); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), account_text); + std::string amount_text (response.get ("amount")); + ASSERT_EQ (nano::dev::constants.genesis_amount.convert_to (), amount_text); } TEST (rpc, block_info_pruning) { nano::system system; nano::node_config node_config0 (nano::get_available_port (), system.logging); - node_config0.receive_minimum = nano::genesis_amount; // Prevent auto-receive & receive1 block conflicts + node_config0.receive_minimum = nano::dev::constants.genesis_amount; // Prevent auto-receive & receive1 block conflicts auto & node0 = *system.add_node (node_config0); nano::node_config node_config1 (nano::get_available_port (), system.logging); node_config1.enable_voting = false; // Remove after allowing pruned voting nano::node_flags node_flags; node_flags.enable_pruning = true; - auto & node1 = *add_ipc_enabled_node (system, node_config1, node_flags); - auto latest (node1.latest (nano::dev_genesis_key.pub)); - auto send1 (std::make_shared (latest, nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest))); - node1.process_active (send1); - auto receive1 (std::make_shared (send1->hash (), send1->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (send1->hash ()))); - node1.process_active (receive1); - node1.block_processor.flush (); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 3 && node1.confirmation_height_processor.current ().is_zero () && node1.confirmation_height_processor.awaiting_processing_size () == 0); + auto node1 = add_ipc_enabled_node (system, node_config1, node_flags); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + auto send1 (std::make_shared (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest))); + node1->process_active (send1); + auto receive1 (std::make_shared (send1->hash (), send1->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (send1->hash ()))); + node1->process_active (receive1); + node1->block_processor.flush (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + ASSERT_TIMELY (5s, node1->ledger.cache.cemented_count == 3 && node1->confirmation_height_processor.current ().is_zero () && node1->confirmation_height_processor.awaiting_processing_size () == 0); // Pruning action { - auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (1, node1.ledger.pruning_action (transaction, send1->hash (), 1)); - ASSERT_TRUE (node1.store.block_exists (transaction, receive1->hash ())); + auto transaction (node1->store.tx_begin_write ()); + ASSERT_EQ (1, node1->ledger.pruning_action (transaction, send1->hash (), 1)); + ASSERT_TRUE (node1->store.block.exists (transaction, receive1->hash ())); } - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node1); // Pruned block boost::property_tree::ptree request; request.put ("action", "block_info"); request.put ("hash", send1->hash ().to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_blocks::not_found).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (std::error_code (nano::error_blocks::not_found).message (), response.get ("error")); // Existing block with previous pruned boost::property_tree::ptree request2; request2.put ("action", "block_info"); request2.put ("json_block", "true"); request2.put ("hash", receive1->hash ().to_string ()); - test_response response2 (request2, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response2.status != 0); - ASSERT_EQ (200, response2.status); - std::string account_text (response2.json.get ("block_account")); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), account_text); - boost::optional amount (response2.json.get_optional ("amount")); + auto response2 (wait_response (system, rpc, request2)); + std::string account_text (response2.get ("block_account")); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), account_text); + boost::optional amount (response2.get_optional ("amount")); ASSERT_FALSE (amount.is_initialized ()); // Cannot calculate amount bool json_error{ false }; - nano::receive_block receive_from_json (json_error, response2.json.get_child ("contents")); + nano::receive_block receive_from_json (json_error, response2.get_child ("contents")); ASSERT_FALSE (json_error); ASSERT_EQ (receive1->full_hash (), receive_from_json.full_hash ()); - std::string balance_text (response2.json.get ("balance")); - ASSERT_EQ (nano::genesis_amount.convert_to (), balance_text); - ASSERT_TRUE (response2.json.get ("confirmed")); + std::string balance_text (response2.get ("balance")); + ASSERT_EQ (nano::dev::constants.genesis_amount.convert_to (), balance_text); + ASSERT_TRUE (response2.get ("confirmed")); + std::string successor_text (response2.get ("successor")); + ASSERT_EQ (successor_text, nano::block_hash (0).to_string ()); // receive1 block doesn't have successor yet } TEST (rpc, pruned_exists) { nano::system system; nano::node_config node_config0 (nano::get_available_port (), system.logging); - node_config0.receive_minimum = nano::genesis_amount; // Prevent auto-receive & receive1 block conflicts + node_config0.receive_minimum = nano::dev::constants.genesis_amount; // Prevent auto-receive & receive1 block conflicts auto & node0 = *system.add_node (node_config0); nano::node_config node_config1 (nano::get_available_port (), system.logging); node_config1.enable_voting = false; // Remove after allowing pruned voting nano::node_flags node_flags; node_flags.enable_pruning = true; - auto & node1 = *add_ipc_enabled_node (system, node_config1, node_flags); - auto latest (node1.latest (nano::dev_genesis_key.pub)); - auto send1 (std::make_shared (latest, nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest))); - node1.process_active (send1); - auto receive1 (std::make_shared (send1->hash (), send1->hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (send1->hash ()))); - node1.process_active (receive1); - node1.block_processor.flush (); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - ASSERT_TIMELY (5s, node1.ledger.cache.cemented_count == 3 && node1.confirmation_height_processor.current ().is_zero () && node1.confirmation_height_processor.awaiting_processing_size () == 0); + auto node1 = add_ipc_enabled_node (system, node_config1, node_flags); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + auto send1 (std::make_shared (latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest))); + node1->process_active (send1); + auto receive1 (std::make_shared (send1->hash (), send1->hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (send1->hash ()))); + node1->process_active (receive1); + node1->block_processor.flush (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + ASSERT_TIMELY (5s, node1->ledger.cache.cemented_count == 3 && node1->confirmation_height_processor.current ().is_zero () && node1->confirmation_height_processor.awaiting_processing_size () == 0); // Pruning action { - auto transaction (node1.store.tx_begin_write ()); - ASSERT_EQ (1, node1.ledger.pruning_action (transaction, send1->hash (), 1)); - ASSERT_TRUE (node1.store.block_exists (transaction, receive1->hash ())); + auto transaction (node1->store.tx_begin_write ()); + ASSERT_EQ (1, node1->ledger.pruning_action (transaction, send1->hash (), 1)); + ASSERT_TRUE (node1->store.block.exists (transaction, receive1->hash ())); } - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node1); // Pruned block boost::property_tree::ptree request; request.put ("action", "pruned_exists"); request.put ("hash", send1->hash ().to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_TRUE (response.json.get ("exists")); + auto response (wait_response (system, rpc, request)); + ASSERT_TRUE (response.get ("exists")); // Existing block with previous pruned boost::property_tree::ptree request2; request2.put ("action", "pruned_exists"); request2.put ("hash", receive1->hash ().to_string ()); - test_response response2 (request2, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response2.status != 0); - ASSERT_EQ (200, response2.status); - ASSERT_FALSE (response2.json.get ("exists")); + auto response2 (wait_response (system, rpc, request2)); + ASSERT_FALSE (response2.get ("exists")); } TEST (rpc, work_peers_all) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "work_peer_add"); request.put ("address", "::1"); request.put ("port", "0"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string success (response.json.get ("success", "")); + auto response (wait_response (system, rpc, request)); + std::string success (response.get ("success", "")); ASSERT_TRUE (success.empty ()); boost::property_tree::ptree request1; request1.put ("action", "work_peers"); - test_response response1 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response1.status != 0); - ASSERT_EQ (200, response1.status); - auto & peers_node (response1.json.get_child ("work_peers")); + auto response1 (wait_response (system, rpc, request1)); + auto & peers_node (response1.get_child ("work_peers")); std::vector peers; for (auto i (peers_node.begin ()), n (peers_node.end ()); i != n; ++i) { @@ -5162,16 +4099,11 @@ TEST (rpc, work_peers_all) ASSERT_EQ ("::1:0", peers[0]); boost::property_tree::ptree request2; request2.put ("action", "work_peers_clear"); - test_response response2 (request2, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response2.status != 0); - ASSERT_EQ (200, response2.status); - success = response2.json.get ("success", ""); + auto response2 (wait_response (system, rpc, request2)); + success = response2.get ("success", ""); ASSERT_TRUE (success.empty ()); - test_response response3 (request1, rpc.config.port, system.io_ctx); - system.deadline_set (5s); - ASSERT_TIMELY (10s, response3.status != 0); - ASSERT_EQ (200, response3.status); - peers_node = response3.json.get_child ("work_peers"); + auto response3 (wait_response (system, rpc, request1, 10s)); + peers_node = response3.get_child ("work_peers"); ASSERT_EQ (0, peers_node.size ()); } @@ -5180,35 +4112,23 @@ TEST (rpc, ledger) nano::system system; auto node = add_ipc_enabled_node (system); nano::keypair key; - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - system.wallet (0)->insert_adhoc (key.prv); - auto & node1 (*system.nodes[0]); - auto latest (node1.latest (nano::dev_genesis_key.pub)); - auto genesis_balance (nano::genesis_amount); + auto latest (node->latest (nano::dev::genesis_key.pub)); + auto genesis_balance (nano::dev::constants.genesis_amount); auto send_amount (genesis_balance - 100); genesis_balance -= send_amount; - nano::send_block send (latest, key.pub, genesis_balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - node1.process (send); - nano::open_block open (send.hash (), nano::dev_genesis_key.pub, key.pub, key.prv, key.pub, *node1.work_generate_blocking (key.pub)); - ASSERT_EQ (nano::process_result::progress, node1.process (open).code); + nano::send_block send (latest, key.pub, genesis_balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (latest)); + ASSERT_EQ (nano::process_result::progress, node->process (send).code); + nano::open_block open (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *node->work_generate_blocking (key.pub)); + ASSERT_EQ (nano::process_result::progress, node->process (open).code); auto time (nano::seconds_since_epoch ()); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "ledger"); request.put ("sorting", true); request.put ("count", "1"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - for (auto & account : response.json.get_child ("accounts")) + auto response (wait_response (system, rpc, request)); + for (auto & account : response.get_child ("accounts")) { std::string account_text (account.first); ASSERT_EQ (key.pub.to_account (), account_text); @@ -5237,9 +4157,8 @@ TEST (rpc, ledger) request.put ("pending", true); request.put ("representative", true); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - for (auto & account : response.json.get_child ("accounts")) + auto response (wait_response (system, rpc, request)); + for (auto & account : response.get_child ("accounts")) { boost::optional weight (account.second.get_optional ("weight")); ASSERT_TRUE (weight.is_initialized ()); @@ -5249,16 +4168,15 @@ TEST (rpc, ledger) ASSERT_EQ ("0", pending.get ()); boost::optional representative (account.second.get_optional ("representative")); ASSERT_TRUE (representative.is_initialized ()); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), representative.get ()); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), representative.get ()); } } // Test threshold request.put ("count", 2); request.put ("threshold", genesis_balance + 1); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - auto & accounts (response.json.get_child ("accounts")); + auto response (wait_response (system, rpc, request)); + auto & accounts (response.get_child ("accounts")); ASSERT_EQ (1, accounts.size ()); auto account (accounts.begin ()); ASSERT_EQ (key.pub.to_account (), account->first); @@ -5267,18 +4185,17 @@ TEST (rpc, ledger) } auto send2_amount (50); genesis_balance -= send2_amount; - nano::send_block send2 (send.hash (), key.pub, genesis_balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (send.hash ())); - scoped_thread_name_io.reset (); - node1.process (send2); - scoped_thread_name_io.renew (); + nano::send_block send2 (send.hash (), key.pub, genesis_balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (send.hash ())); + rpc_ctx->io_scope->reset (); + ASSERT_EQ (nano::process_result::progress, node->process (send2).code); + rpc_ctx->io_scope->renew (); // When asking for pending, pending amount is taken into account for threshold so the account must show up request.put ("count", 2); request.put ("threshold", (send_amount + send2_amount).convert_to ()); request.put ("pending", true); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - auto & accounts (response.json.get_child ("accounts")); + auto response (wait_response (system, rpc, request)); + auto & accounts (response.get_child ("accounts")); ASSERT_EQ (1, accounts.size ()); auto account (accounts.begin ()); ASSERT_EQ (key.pub.to_account (), account->first); @@ -5293,22 +4210,13 @@ TEST (rpc, accounts_create) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "accounts_create"); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); request.put ("count", "8"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & accounts (response.json.get_child ("accounts")); + auto response (wait_response (system, rpc, request)); + auto & accounts (response.get_child ("accounts")); for (auto i (accounts.begin ()), n (accounts.end ()); i != n; ++i) { std::string account_text (i->second.get ("")); @@ -5322,115 +4230,97 @@ TEST (rpc, accounts_create) TEST (rpc, block_create) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); + auto node1 = add_ipc_enabled_node (system); nano::keypair key; - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - auto latest (node1.latest (nano::dev_genesis_key.pub)); - auto send_work = *node1.work_generate_blocking (latest); - nano::send_block send (latest, key.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, send_work); - auto open_work = *node1.work_generate_blocking (key.pub); - nano::open_block open (send.hash (), nano::dev_genesis_key.pub, key.pub, key.prv, key.pub, open_work); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + auto send_work = *node1->work_generate_blocking (latest); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, send_work); + auto open_work = *node1->work_generate_blocking (key.pub); + nano::open_block open (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, open_work); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "block_create"); request.put ("type", "send"); - request.put ("wallet", node1.wallets.items.begin ()->first.to_string ()); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); + request.put ("wallet", node1->wallets.items.begin ()->first.to_string ()); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); request.put ("previous", latest.to_string ()); request.put ("amount", "340282366920938463463374607431768211355"); request.put ("destination", key.pub.to_account ()); request.put ("work", nano::to_string_hex (send_work)); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string send_hash (response.json.get ("hash")); + auto response (wait_response (system, rpc, request)); + std::string send_hash (response.get ("hash")); ASSERT_EQ (send.hash ().to_string (), send_hash); - std::string send_difficulty (response.json.get ("difficulty")); - ASSERT_EQ (nano::to_string_hex (send.difficulty ()), send_difficulty); - auto send_text (response.json.get ("block")); + std::string send_difficulty (response.get ("difficulty")); + ASSERT_EQ (nano::to_string_hex (nano::dev::network_params.work.difficulty (send)), send_difficulty); + auto send_text (response.get ("block")); boost::property_tree::ptree block_l; std::stringstream block_stream (send_text); boost::property_tree::read_json (block_stream, block_l); auto send_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (send.hash (), send_block->hash ()); - scoped_thread_name_io.reset (); - node1.process (send); - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->reset (); + ASSERT_EQ (nano::process_result::progress, node1->process (send).code); + rpc_ctx->io_scope->renew (); boost::property_tree::ptree request1; request1.put ("action", "block_create"); request1.put ("type", "open"); std::string key_text; key.prv.encode_hex (key_text); request1.put ("key", key_text); - request1.put ("representative", nano::dev_genesis_key.pub.to_account ()); + request1.put ("representative", nano::dev::genesis_key.pub.to_account ()); request1.put ("source", send.hash ().to_string ()); request1.put ("work", nano::to_string_hex (open_work)); - test_response response1 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response1.status != 0); - ASSERT_EQ (200, response1.status); - std::string open_hash (response1.json.get ("hash")); + auto response1 (wait_response (system, rpc, request1)); + std::string open_hash (response1.get ("hash")); ASSERT_EQ (open.hash ().to_string (), open_hash); - auto open_text (response1.json.get ("block")); + auto open_text (response1.get ("block")); std::stringstream block_stream1 (open_text); boost::property_tree::read_json (block_stream1, block_l); auto open_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (open.hash (), open_block->hash ()); - scoped_thread_name_io.reset (); - ASSERT_EQ (nano::process_result::progress, node1.process (open).code); - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->reset (); + ASSERT_EQ (nano::process_result::progress, node1->process (open).code); + rpc_ctx->io_scope->renew (); request1.put ("representative", key.pub.to_account ()); - test_response response2 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response2.status != 0); - ASSERT_EQ (200, response2.status); - std::string open2_hash (response2.json.get ("hash")); + auto response2 (wait_response (system, rpc, request1)); + std::string open2_hash (response2.get ("hash")); ASSERT_NE (open.hash ().to_string (), open2_hash); // different blocks with wrong representative - auto change_work = *node1.work_generate_blocking (open.hash ()); + auto change_work = *node1->work_generate_blocking (open.hash ()); nano::change_block change (open.hash (), key.pub, key.prv, key.pub, change_work); request1.put ("type", "change"); request1.put ("work", nano::to_string_hex (change_work)); - test_response response4 (request1, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response4.status != 0); - ASSERT_EQ (200, response4.status); - std::string change_hash (response4.json.get ("hash")); + auto response4 (wait_response (system, rpc, request1)); + std::string change_hash (response4.get ("hash")); ASSERT_EQ (change.hash ().to_string (), change_hash); - auto change_text (response4.json.get ("block")); + auto change_text (response4.get ("block")); std::stringstream block_stream4 (change_text); boost::property_tree::read_json (block_stream4, block_l); auto change_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (change.hash (), change_block->hash ()); - scoped_thread_name_io.reset (); - ASSERT_EQ (nano::process_result::progress, node1.process (change).code); - nano::send_block send2 (send.hash (), key.pub, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (send.hash ())); - ASSERT_EQ (nano::process_result::progress, node1.process (send2).code); - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->reset (); + ASSERT_EQ (nano::process_result::progress, node1->process (change).code); + nano::send_block send2 (send.hash (), key.pub, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (send.hash ())); + ASSERT_EQ (nano::process_result::progress, node1->process (send2).code); + rpc_ctx->io_scope->renew (); boost::property_tree::ptree request2; request2.put ("action", "block_create"); request2.put ("type", "receive"); - request2.put ("wallet", node1.wallets.items.begin ()->first.to_string ()); + request2.put ("wallet", node1->wallets.items.begin ()->first.to_string ()); request2.put ("account", key.pub.to_account ()); request2.put ("source", send2.hash ().to_string ()); request2.put ("previous", change.hash ().to_string ()); - request2.put ("work", nano::to_string_hex (*node1.work_generate_blocking (change.hash ()))); - test_response response5 (request2, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response5.status != 0); - ASSERT_EQ (200, response5.status); - std::string receive_hash (response4.json.get ("hash")); - auto receive_text (response5.json.get ("block")); + request2.put ("work", nano::to_string_hex (*node1->work_generate_blocking (change.hash ()))); + auto response5 (wait_response (system, rpc, request2)); + std::string receive_hash (response4.get ("hash")); + auto receive_text (response5.get ("block")); std::stringstream block_stream5 (change_text); boost::property_tree::read_json (block_stream5, block_l); auto receive_block (nano::deserialize_block_json (block_l)); ASSERT_EQ (receive_hash, receive_block->hash ().to_string ()); - node1.process_active (std::move (receive_block)); - latest = node1.latest (key.pub); + node1->process_active (std::move (receive_block)); + latest = node1->latest (key.pub); ASSERT_EQ (receive_hash, latest.to_string ()); } @@ -5439,31 +4329,21 @@ TEST (rpc, block_create_state) nano::system system; auto node = add_ipc_enabled_node (system); nano::keypair key; - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block_create"); request.put ("type", "state"); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); - request.put ("previous", genesis.hash ().to_string ()); - request.put ("representative", nano::dev_genesis_key.pub.to_account ()); - request.put ("balance", (nano::genesis_amount - nano::MBAN_ratio).convert_to ()); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); + request.put ("previous", nano::dev::genesis->hash ().to_string ()); + request.put ("representative", nano::dev::genesis_key.pub.to_account ()); + request.put ("balance", (nano::dev::constants.genesis_amount - nano::MBAN_ratio).convert_to ()); request.put ("link", key.pub.to_account ()); - request.put ("work", nano::to_string_hex (*node->work_generate_blocking (genesis.hash ()))); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string state_hash (response.json.get ("hash")); - auto state_text (response.json.get ("block")); + request.put ("work", nano::to_string_hex (*node->work_generate_blocking (nano::dev::genesis->hash ()))); + auto response (wait_response (system, rpc, request)); + std::string state_hash (response.get ("hash")); + auto state_text (response.get ("block")); std::stringstream block_stream (state_text); boost::property_tree::ptree block_l; boost::property_tree::read_json (block_stream, block_l); @@ -5471,7 +4351,7 @@ TEST (rpc, block_create_state) ASSERT_NE (nullptr, state_block); ASSERT_EQ (nano::block_type::state, state_block->type ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ()); - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); auto process_result (node->process (*state_block)); ASSERT_EQ (nano::process_result::progress, process_result.code); } @@ -5481,33 +4361,23 @@ TEST (rpc, block_create_state_open) nano::system system; auto node = add_ipc_enabled_node (system); nano::keypair key; - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto send_block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, nano::MBAN_ratio)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto send_block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::MBAN_ratio)); ASSERT_NE (nullptr, send_block); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block_create"); request.put ("type", "state"); request.put ("key", key.prv.to_string ()); request.put ("account", key.pub.to_account ()); request.put ("previous", 0); - request.put ("representative", nano::dev_genesis_key.pub.to_account ()); + request.put ("representative", nano::dev::genesis_key.pub.to_account ()); request.put ("balance", nano::MBAN_ratio.convert_to ()); request.put ("link", send_block->hash ().to_string ()); request.put ("work", nano::to_string_hex (*node->work_generate_blocking (key.pub))); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string state_hash (response.json.get ("hash")); - auto state_text (response.json.get ("block")); + auto response (wait_response (system, rpc, request)); + std::string state_hash (response.get ("hash")); + auto state_text (response.get ("block")); std::stringstream block_stream (state_text); boost::property_tree::ptree block_l; boost::property_tree::read_json (block_stream, block_l); @@ -5515,10 +4385,10 @@ TEST (rpc, block_create_state_open) ASSERT_NE (nullptr, state_block); ASSERT_EQ (nano::block_type::state, state_block->type ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ()); - auto difficulty (state_block->difficulty ()); - ASSERT_GT (difficulty, nano::work_threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_0, false, true, false))); + auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); + ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_0, false, true, false))); ASSERT_TRUE (node->latest (key.pub).is_zero ()); - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); auto process_result (node->process (*state_block)); ASSERT_EQ (nano::process_result::progress, process_result.code); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_0); @@ -5529,8 +4399,6 @@ TEST (rpc, block_create_state_open) // Missing "work" parameter should cause work to be generated for us. TEST (rpc, block_create_state_request_work) { - nano::genesis genesis; - // Test work generation for state blocks both with and without previous (in the latter // case, the account will be used for work generation) std::unique_ptr epoch2; @@ -5546,34 +4414,24 @@ TEST (rpc, block_create_state_request_work) nano::system system; auto node = add_ipc_enabled_node (system); nano::keypair key; - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block_create"); request.put ("type", "state"); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); - request.put ("representative", nano::dev_genesis_key.pub.to_account ()); - request.put ("balance", (nano::genesis_amount - nano::MBAN_ratio).convert_to ()); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); + request.put ("representative", nano::dev::genesis_key.pub.to_account ()); + request.put ("balance", (nano::dev::constants.genesis_amount - nano::MBAN_ratio).convert_to ()); request.put ("link", key.pub.to_account ()); request.put ("previous", previous); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); boost::property_tree::ptree block_l; - std::stringstream block_stream (response.json.get ("block")); + std::stringstream block_stream (response.get ("block")); boost::property_tree::read_json (block_stream, block_l); auto block (nano::deserialize_block_json (block_l)); ASSERT_NE (nullptr, block); - ASSERT_GE (block->difficulty (), node->default_difficulty (nano::work_version::work_1)); + ASSERT_GE (nano::dev::network_params.work.difficulty (*block), node->default_difficulty (nano::work_version::work_1)); } } @@ -5582,34 +4440,24 @@ TEST (rpc, block_create_open_epoch_v2) nano::system system; auto node = add_ipc_enabled_node (system); nano::keypair key; - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_1)); ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_2)); - auto send_block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, nano::MBAN_ratio)); + auto send_block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::MBAN_ratio)); ASSERT_NE (nullptr, send_block); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block_create"); request.put ("type", "state"); request.put ("key", key.prv.to_string ()); request.put ("account", key.pub.to_account ()); request.put ("previous", 0); - request.put ("representative", nano::dev_genesis_key.pub.to_account ()); + request.put ("representative", nano::dev::genesis_key.pub.to_account ()); request.put ("balance", nano::MBAN_ratio.convert_to ()); request.put ("link", send_block->hash ().to_string ()); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string state_hash (response.json.get ("hash")); - auto state_text (response.json.get ("block")); + auto response (wait_response (system, rpc, request)); + std::string state_hash (response.get ("hash")); + auto state_text (response.get ("block")); std::stringstream block_stream (state_text); boost::property_tree::ptree block_l; boost::property_tree::read_json (block_stream, block_l); @@ -5617,10 +4465,10 @@ TEST (rpc, block_create_open_epoch_v2) ASSERT_NE (nullptr, state_block); ASSERT_EQ (nano::block_type::state, state_block->type ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ()); - auto difficulty (state_block->difficulty ()); - ASSERT_GT (difficulty, nano::work_threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); + auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); + ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); ASSERT_TRUE (node->latest (key.pub).is_zero ()); - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); auto process_result (node->process (*state_block)); ASSERT_EQ (nano::process_result::progress, process_result.code); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); @@ -5633,37 +4481,27 @@ TEST (rpc, block_create_receive_epoch_v2) nano::system system; auto node = add_ipc_enabled_node (system); nano::keypair key; - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_1)); - auto send_block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, nano::MBAN_ratio)); + auto send_block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::MBAN_ratio)); ASSERT_NE (nullptr, send_block); - nano::state_block open (key.pub, 0, nano::dev_genesis_key.pub, nano::MBAN_ratio, send_block->hash (), key.prv, key.pub, *node->work_generate_blocking (key.pub)); + nano::state_block open (key.pub, 0, nano::dev::genesis_key.pub, nano::MBAN_ratio, send_block->hash (), key.prv, key.pub, *node->work_generate_blocking (key.pub)); ASSERT_EQ (nano::process_result::progress, node->process (open).code); ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_2)); - auto send_block_2 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, nano::MBAN_ratio)); + auto send_block_2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::MBAN_ratio)); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block_create"); request.put ("type", "state"); request.put ("key", key.prv.to_string ()); request.put ("account", key.pub.to_account ()); request.put ("previous", open.hash ().to_string ()); - request.put ("representative", nano::dev_genesis_key.pub.to_account ()); + request.put ("representative", nano::dev::genesis_key.pub.to_account ()); request.put ("balance", (2 * nano::MBAN_ratio).convert_to ()); request.put ("link", send_block_2->hash ().to_string ()); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string state_hash (response.json.get ("hash")); - auto state_text (response.json.get ("block")); + auto response (wait_response (system, rpc, request)); + std::string state_hash (response.get ("hash")); + auto state_text (response.get ("block")); std::stringstream block_stream (state_text); boost::property_tree::ptree block_l; boost::property_tree::read_json (block_stream, block_l); @@ -5671,9 +4509,9 @@ TEST (rpc, block_create_receive_epoch_v2) ASSERT_NE (nullptr, state_block); ASSERT_EQ (nano::block_type::state, state_block->type ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ()); - auto difficulty (state_block->difficulty ()); - ASSERT_GT (difficulty, nano::work_threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); - scoped_thread_name_io.reset (); + auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); + ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, false, true, false))); + rpc_ctx->io_scope->reset (); auto process_result (node->process (*state_block)); ASSERT_EQ (nano::process_result::progress, process_result.code); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); @@ -5686,36 +4524,26 @@ TEST (rpc, block_create_send_epoch_v2) nano::system system; auto node = add_ipc_enabled_node (system); nano::keypair key; - nano::genesis genesis; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_1)); ASSERT_NE (nullptr, system.upgrade_genesis_epoch (*node, nano::epoch::epoch_2)); - auto send_block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, nano::MBAN_ratio)); + auto send_block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::MBAN_ratio)); ASSERT_NE (nullptr, send_block); - nano::state_block open (key.pub, 0, nano::dev_genesis_key.pub, nano::MBAN_ratio, send_block->hash (), key.prv, key.pub, *node->work_generate_blocking (key.pub)); + nano::state_block open (key.pub, 0, nano::dev::genesis_key.pub, nano::MBAN_ratio, send_block->hash (), key.prv, key.pub, *node->work_generate_blocking (key.pub)); ASSERT_EQ (nano::process_result::progress, node->process (open).code); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block_create"); request.put ("type", "state"); request.put ("key", key.prv.to_string ()); request.put ("account", key.pub.to_account ()); request.put ("previous", open.hash ().to_string ()); - request.put ("representative", nano::dev_genesis_key.pub.to_account ()); + request.put ("representative", nano::dev::genesis_key.pub.to_account ()); request.put ("balance", 0); - request.put ("link", nano::dev_genesis_key.pub.to_string ()); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string state_hash (response.json.get ("hash")); - auto state_text (response.json.get ("block")); + request.put ("link", nano::dev::genesis_key.pub.to_string ()); + auto response (wait_response (system, rpc, request)); + std::string state_hash (response.get ("hash")); + auto state_text (response.get ("block")); std::stringstream block_stream (state_text); boost::property_tree::ptree block_l; boost::property_tree::read_json (block_stream, block_l); @@ -5723,9 +4551,9 @@ TEST (rpc, block_create_send_epoch_v2) ASSERT_NE (nullptr, state_block); ASSERT_EQ (nano::block_type::state, state_block->type ()); ASSERT_EQ (state_hash, state_block->hash ().to_string ()); - auto difficulty (state_block->difficulty ()); - ASSERT_GT (difficulty, nano::work_threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, true, false, false))); - scoped_thread_name_io.reset (); + auto difficulty (nano::dev::network_params.work.difficulty (*state_block)); + ASSERT_GT (difficulty, nano::dev::network_params.work.threshold (state_block->work_version (), nano::block_details (nano::epoch::epoch_2, true, false, false))); + rpc_ctx->io_scope->reset (); auto process_result (node->process (*state_block)); ASSERT_EQ (nano::process_result::progress, process_result.code); ASSERT_EQ (state_block->sideband ().details.epoch, nano::epoch::epoch_2); @@ -5736,27 +4564,18 @@ TEST (rpc, block_create_send_epoch_v2) TEST (rpc, block_hash) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); nano::keypair key; - auto latest (node1.latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, key.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); boost::property_tree::ptree request; request.put ("action", "block_hash"); std::string json; send.serialize_json (json); request.put ("block", json); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string send_hash (response.json.get ("hash")); + auto response (wait_response (system, rpc, request)); + std::string send_hash (response.get ("hash")); ASSERT_EQ (send.hash ().to_string (), send_hash); } @@ -5764,14 +4583,7 @@ TEST (rpc, wallet_lock) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); @@ -5781,10 +4593,8 @@ TEST (rpc, wallet_lock) } request.put ("wallet", wallet); request.put ("action", "wallet_lock"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string account_text1 (response.json.get ("locked")); + auto response (wait_response (system, rpc, request)); + std::string account_text1 (response.get ("locked")); ASSERT_EQ (account_text1, "1"); auto transaction (system.wallet (0)->wallets.tx_begin_read ()); ASSERT_FALSE (system.wallet (0)->store.valid_password (transaction)); @@ -5794,23 +4604,14 @@ TEST (rpc, wallet_locked) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("action", "wallet_locked"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string account_text1 (response.json.get ("locked")); + auto response (wait_response (system, rpc, request)); + std::string account_text1 (response.get ("locked")); ASSERT_EQ (account_text1, "0"); } @@ -5818,55 +4619,38 @@ TEST (rpc, wallet_create_fail) { nano::system system; auto node = add_ipc_enabled_node (system); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); // lmdb_max_dbs should be removed once the wallet store is refactored to support more wallets. for (int i = 0; i < 127; i++) { node->wallets.create (nano::random_wallet_id ()); } - rpc.start (); - scoped_io_thread_name_change scoped_thread_name_io; + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "wallet_create"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (std::error_code (nano::error_common::wallet_lmdb_max_dbs).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (std::error_code (nano::error_common::wallet_lmdb_max_dbs).message (), response.get ("error")); } TEST (rpc, wallet_ledger) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); + auto node1 = add_ipc_enabled_node (system); nano::keypair key; - nano::genesis genesis; system.wallet (0)->insert_adhoc (key.prv); - auto latest (node1.latest (nano::dev_genesis_key.pub)); - nano::send_block send (latest, key.pub, 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node1.work_generate_blocking (latest)); - node1.process (send); - nano::open_block open (send.hash (), nano::dev_genesis_key.pub, key.pub, key.prv, key.pub, *node1.work_generate_blocking (key.pub)); - ASSERT_EQ (nano::process_result::progress, node1.process (open).code); + auto latest (node1->latest (nano::dev::genesis_key.pub)); + nano::send_block send (latest, key.pub, 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node1->work_generate_blocking (latest)); + ASSERT_EQ (nano::process_result::progress, node1->process (send).code); + nano::open_block open (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *node1->work_generate_blocking (key.pub)); + ASSERT_EQ (nano::process_result::progress, node1->process (open).code); auto time (nano::seconds_since_epoch ()); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "wallet_ledger"); - request.put ("wallet", node1.wallets.items.begin ()->first.to_string ()); + request.put ("wallet", node1->wallets.items.begin ()->first.to_string ()); request.put ("sorting", "1"); request.put ("count", "1"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - for (auto & accounts : response.json.get_child ("accounts")) + auto response (wait_response (system, rpc, request)); + for (auto & accounts : response.get_child ("accounts")) { std::string account_text (accounts.first); ASSERT_EQ (key.pub.to_account (), account_text); @@ -5893,9 +4677,8 @@ TEST (rpc, wallet_ledger) request.put ("weight", "true"); request.put ("pending", "1"); request.put ("representative", "false"); - test_response response2 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response2.status != 0); - for (auto & accounts : response2.json.get_child ("accounts")) + auto response2 (wait_response (system, rpc, request)); + for (auto & accounts : response2.get_child ("accounts")) { boost::optional weight (accounts.second.get_optional ("weight")); ASSERT_TRUE (weight.is_initialized ()); @@ -5912,14 +4695,7 @@ TEST (rpc, wallet_add_watch) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; std::string wallet; node->wallets.items.begin ()->first.encode_hex (wallet); @@ -5927,15 +4703,13 @@ TEST (rpc, wallet_add_watch) request.put ("action", "wallet_add_watch"); boost::property_tree::ptree entry; boost::property_tree::ptree peers_l; - entry.put ("", nano::dev_genesis_key.pub.to_account ()); + entry.put ("", nano::dev::genesis_key.pub.to_account ()); peers_l.push_back (std::make_pair ("", entry)); request.add_child ("accounts", peers_l); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string success (response.json.get ("success")); + auto response (wait_response (system, rpc, request)); + std::string success (response.get ("success")); ASSERT_TRUE (success.empty ()); - ASSERT_TRUE (system.wallet (0)->exists (nano::dev_genesis_key.pub)); + ASSERT_TRUE (system.wallet (0)->exists (nano::dev::genesis_key.pub)); // Make sure using special wallet key as pubkey fails nano::public_key bad_key (1); @@ -5944,11 +4718,9 @@ TEST (rpc, wallet_add_watch) request.erase ("accounts"); request.add_child ("accounts", peers_l); - test_response response_error (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response_error.status != 0); - ASSERT_EQ (200, response_error.status); + auto response_error (wait_response (system, rpc, request)); std::error_code ec (nano::error_common::bad_public_key); - ASSERT_EQ (response_error.json.get ("error"), ec.message ()); + ASSERT_EQ (response_error.get ("error"), ec.message ()); } TEST (rpc, online_reps) @@ -5957,57 +4729,47 @@ TEST (rpc, online_reps) auto node1 (system.nodes[0]); auto node2 = add_ipc_enabled_node (system); nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_EQ (node2->online_reps.online (), 0); - auto send_block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, nano::MBAN_ratio)); + auto send_block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::MBAN_ratio)); ASSERT_NE (nullptr, send_block); - scoped_io_thread_name_change scoped_thread_name_io; ASSERT_TIMELY (10s, !node2->online_reps.list ().empty ()); - ASSERT_EQ (node2->online_reps.online (), nano::genesis_amount - nano::MBAN_ratio); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*system.nodes[1], node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node2->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + ASSERT_EQ (node2->online_reps.online (), nano::dev::constants.genesis_amount - nano::MBAN_ratio); + auto [rpc, rpc_ctx] = add_rpc (system, node2); boost::property_tree::ptree request; request.put ("action", "representatives_online"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto representatives (response.json.get_child ("representatives")); + auto response (wait_response (system, rpc, request)); + auto representatives (response.get_child ("representatives")); auto item (representatives.begin ()); ASSERT_NE (representatives.end (), item); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), item->second.get ("")); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), item->second.get ("")); boost::optional weight (item->second.get_optional ("weight")); ASSERT_FALSE (weight.is_initialized ()); ASSERT_TIMELY (5s, node2->block (send_block->hash ())); //Test weight option request.put ("weight", "true"); - test_response response2 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response2.status != 0); - auto representatives2 (response2.json.get_child ("representatives")); + auto response2 (wait_response (system, rpc, request)); + auto representatives2 (response2.get_child ("representatives")); auto item2 (representatives2.begin ()); ASSERT_NE (representatives2.end (), item2); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), item2->first); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), item2->first); auto weight2 (item2->second.get ("weight")); - ASSERT_EQ (node2->weight (nano::dev_genesis_key.pub).convert_to (), weight2); + ASSERT_EQ (node2->weight (nano::dev::genesis_key.pub).convert_to (), weight2); //Test accounts filter - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); auto new_rep (system.wallet (1)->deterministic_insert ()); - auto send (system.wallet (0)->send_action (nano::dev_genesis_key.pub, new_rep, node1->config.receive_minimum.number ())); - scoped_thread_name_io.renew (); + auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, new_rep, node1->config.receive_minimum.number ())); + rpc_ctx->io_scope->renew (); ASSERT_NE (nullptr, send); ASSERT_TIMELY (10s, node2->block (send->hash ())); - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); auto receive (system.wallet (1)->receive_action (send->hash (), new_rep, node1->config.receive_minimum.number (), send->link ().as_account ())); - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->renew (); ASSERT_NE (nullptr, receive); ASSERT_TIMELY (5s, node2->block (receive->hash ())); - scoped_thread_name_io.reset (); - auto change (system.wallet (0)->change_action (nano::dev_genesis_key.pub, new_rep)); - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->reset (); + auto change (system.wallet (0)->change_action (nano::dev::genesis_key.pub, new_rep)); + rpc_ctx->io_scope->renew (); ASSERT_NE (nullptr, change); ASSERT_TIMELY (5s, node2->block (change->hash ())); ASSERT_TIMELY (5s, node2->online_reps.list ().size () == 2); @@ -6016,9 +4778,8 @@ TEST (rpc, online_reps) boost::property_tree::ptree filtered_accounts; filtered_accounts.push_back (std::make_pair ("", child_rep)); request.add_child ("accounts", filtered_accounts); - test_response response3 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response3.status != 0); - auto representatives3 (response3.json.get_child ("representatives")); + auto response3 (wait_response (system, rpc, request, 10s)); + auto representatives3 (response3.get_child ("representatives")); auto item3 (representatives3.begin ()); ASSERT_NE (representatives3.end (), item3); ASSERT_EQ (new_rep.to_account (), item3->first); @@ -6035,35 +4796,27 @@ TEST (rpc, confirmation_height_currently_processing) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = add_ipc_enabled_node (system, node_config, node_flags); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - auto previous_genesis_chain_hash = node->latest (nano::dev_genesis_key.pub); + auto previous_genesis_chain_hash = node->latest (nano::dev::genesis_key.pub); { auto transaction = node->store.tx_begin_write (); nano::keypair key1; - nano::send_block send (previous_genesis_chain_hash, key1.pub, nano::genesis_amount - nano::MBAN_ratio - 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (previous_genesis_chain_hash)); + nano::send_block send (previous_genesis_chain_hash, key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio - 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous_genesis_chain_hash)); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); previous_genesis_chain_hash = send.hash (); } - scoped_io_thread_name_change scoped_thread_name_io; - std::shared_ptr frontier; { auto transaction = node->store.tx_begin_read (); - frontier = node->store.block_get (transaction, previous_genesis_chain_hash); + frontier = node->store.block.get (transaction, previous_genesis_chain_hash); } boost::property_tree::ptree request; request.put ("action", "confirmation_height_currently_processing"); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); // Begin process for confirming the block (and setting confirmation height) { @@ -6075,10 +4828,8 @@ TEST (rpc, confirmation_height_currently_processing) // Make the request { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - auto hash (response.json.get ("hash")); + auto response (wait_response (system, rpc, request, 10s)); + auto hash (response.get ("hash")); ASSERT_EQ (frontier->hash ().to_string (), hash); } } @@ -6088,11 +4839,9 @@ TEST (rpc, confirmation_height_currently_processing) // Make the same request, it should now return an error { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request, 10s)); std::error_code ec (nano::error_rpc::confirmation_height_not_processing); - ASSERT_EQ (response.json.get ("error"), ec.message ()); + ASSERT_EQ (response.get ("error"), ec.message ()); } } @@ -6101,24 +4850,15 @@ TEST (rpc, confirmation_history) nano::system system; auto node = add_ipc_enabled_node (system); nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_TRUE (node->active.list_recently_cemented ().empty ()); - auto block (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, nano::MBAN_ratio)); - scoped_io_thread_name_change scoped_thread_name_io; + auto block (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::MBAN_ratio)); ASSERT_TIMELY (10s, !node->active.list_recently_cemented ().empty ()); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "confirmation_history"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto representatives (response.json.get_child ("confirmations")); + auto response (wait_response (system, rpc, request)); + auto representatives (response.get_child ("confirmations")); auto item (representatives.begin ()); ASSERT_NE (representatives.end (), item); auto hash (item->second.get ("hash")); @@ -6132,7 +4872,7 @@ TEST (rpc, confirmation_history) ASSERT_EQ (block->hash ().to_string (), hash); nano::amount tally_num; tally_num.decode_dec (tally); - debug_assert (tally_num == nano::genesis_amount || tally_num == (nano::genesis_amount - nano::MBAN_ratio)); + debug_assert (tally_num == nano::dev::constants.genesis_amount || tally_num == (nano::dev::constants.genesis_amount - nano::MBAN_ratio)); system.stop (); } @@ -6141,27 +4881,18 @@ TEST (rpc, confirmation_history_hash) nano::system system; auto node = add_ipc_enabled_node (system); nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); ASSERT_TRUE (node->active.list_recently_cemented ().empty ()); - auto send1 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, nano::MBAN_ratio)); - auto send2 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, nano::MBAN_ratio)); - auto send3 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, nano::MBAN_ratio)); - scoped_io_thread_name_change scoped_thread_name_io; + auto send1 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::MBAN_ratio)); + auto send2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::MBAN_ratio)); + auto send3 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, nano::MBAN_ratio)); ASSERT_TIMELY (10s, node->active.list_recently_cemented ().size () == 3); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "confirmation_history"); request.put ("hash", send2->hash ().to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto representatives (response.json.get_child ("confirmations")); + auto response (wait_response (system, rpc, request)); + auto representatives (response.get_child ("confirmations")); ASSERT_EQ (representatives.size (), 1); auto item (representatives.begin ()); ASSERT_NE (representatives.end (), item); @@ -6172,7 +4903,7 @@ TEST (rpc, confirmation_history_hash) ASSERT_EQ (send2->hash ().to_string (), hash); nano::amount tally_num; tally_num.decode_dec (tally); - debug_assert (tally_num == nano::genesis_amount || tally_num == (nano::genesis_amount - nano::MBAN_ratio) || tally_num == (nano::genesis_amount - 2 * nano::MBAN_ratio) || tally_num == (nano::genesis_amount - 3 * nano::MBAN_ratio)); + debug_assert (tally_num == nano::dev::constants.genesis_amount || tally_num == (nano::dev::constants.genesis_amount - nano::MBAN_ratio) || tally_num == (nano::dev::constants.genesis_amount - 2 * nano::MBAN_ratio) || tally_num == (nano::dev::constants.genesis_amount - 3 * nano::MBAN_ratio)); system.stop (); } @@ -6180,50 +4911,31 @@ TEST (rpc, block_confirm) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - nano::genesis genesis; - auto send1 (std::make_shared (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *node->work_generate_blocking (genesis.hash ()))); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto send1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *node->work_generate_blocking (nano::dev::genesis->hash ()))); { auto transaction (node->store.tx_begin_write ()); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send1).code); } - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block_confirm"); request.put ("hash", send1->hash ().to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ ("1", response.json.get ("started")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ ("1", response.get ("started")); } TEST (rpc, block_confirm_absent) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block_confirm"); request.put ("hash", "0"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_blocks::not_found).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (std::error_code (nano::error_blocks::not_found).message (), response.get ("error")); } TEST (rpc, block_confirm_confirmed) @@ -6237,31 +4949,21 @@ TEST (rpc, block_confirm_confirmed) config.callback_target = "/"; config.logging.init (path); auto node = add_ipc_enabled_node (system, config); - nano::genesis genesis; { auto transaction (node->store.tx_begin_read ()); - ASSERT_TRUE (node->ledger.block_confirmed (transaction, genesis.hash ())); + ASSERT_TRUE (node->ledger.block_confirmed (transaction, nano::dev::genesis->hash ())); } ASSERT_EQ (0, node->stats.count (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out)); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block_confirm"); - request.put ("hash", genesis.hash ().to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ ("1", response.json.get ("started")); + request.put ("hash", nano::dev::genesis->hash ().to_string ()); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ ("1", response.get ("started")); // Check confirmation history auto confirmed (node->active.list_recently_cemented ()); ASSERT_EQ (1, confirmed.size ()); - ASSERT_EQ (nano::genesis_hash, confirmed.begin ()->winner->hash ()); + ASSERT_EQ (nano::dev::genesis->hash (), confirmed.begin ()->winner->hash ()); // Check callback ASSERT_TIMELY (10s, node->stats.count (nano::stat::type::error, nano::stat::detail::http_callback, nano::stat::dir::out) != 0); // Callback result is error because callback target port isn't listening @@ -6273,44 +4975,27 @@ TEST (rpc, node_id) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "node_id"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (node->node_id.prv.to_string (), response.json.get ("private")); - ASSERT_EQ (node->node_id.pub.to_account (), response.json.get ("as_account")); - ASSERT_EQ (node->node_id.pub.to_node_id (), response.json.get ("node_id")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (node->node_id.prv.to_string (), response.get ("private")); + ASSERT_EQ (node->node_id.pub.to_account (), response.get ("as_account")); + ASSERT_EQ (node->node_id.pub.to_node_id (), response.get ("node_id")); } TEST (rpc, stats_clear) -{ - nano::system system; - auto node = add_ipc_enabled_node (system); - nano::keypair key; - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); +{ + nano::system system; + auto node = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node); + nano::keypair key; node->stats.inc (nano::stat::type::ledger, nano::stat::dir::in); ASSERT_EQ (1, node->stats.count (nano::stat::type::ledger, nano::stat::dir::in)); boost::property_tree::ptree request; request.put ("action", "stats_clear"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - std::string success (response.json.get ("success")); + auto response (wait_response (system, rpc, request)); + std::string success (response.get ("success")); ASSERT_TRUE (success.empty ()); ASSERT_EQ (0, node->stats.count (nano::stat::type::ledger, nano::stat::dir::in)); ASSERT_LE (node->stats.last_reset ().count (), 5); @@ -6319,38 +5004,28 @@ TEST (rpc, stats_clear) TEST (rpc, unchecked) { nano::system system; - auto & node = *add_ipc_enabled_node (system); + auto node = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node); nano::keypair key; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); auto open (std::make_shared (key.pub, 0, key.pub, 1, key.pub, key.prv, key.pub, *system.work.generate (key.pub))); auto open2 (std::make_shared (key.pub, 0, key.pub, 2, key.pub, key.prv, key.pub, *system.work.generate (key.pub))); - node.process_active (open); - node.process_active (open2); - node.block_processor.flush (); + node->process_active (open); + node->process_active (open2); + node->block_processor.flush (); boost::property_tree::ptree request; request.put ("action", "unchecked"); request.put ("count", 2); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & blocks (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + auto & blocks (response.get_child ("blocks")); ASSERT_EQ (2, blocks.size ()); ASSERT_EQ (1, blocks.count (open->hash ().to_string ())); ASSERT_EQ (1, blocks.count (open2->hash ().to_string ())); } request.put ("json_block", true); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & blocks (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + auto & blocks (response.get_child ("blocks")); ASSERT_EQ (2, blocks.size ()); auto & open_block (blocks.get_child (open->hash ().to_string ())); ASSERT_EQ ("state", open_block.get ("type")); @@ -6360,37 +5035,27 @@ TEST (rpc, unchecked) TEST (rpc, unchecked_get) { nano::system system; - auto & node = *add_ipc_enabled_node (system); + auto node = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node); nano::keypair key; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); auto open (std::make_shared (key.pub, 0, key.pub, 1, key.pub, key.prv, key.pub, *system.work.generate (key.pub))); - node.process_active (open); - node.block_processor.flush (); + node->process_active (open); + node->block_processor.flush (); boost::property_tree::ptree request; request.put ("action", "unchecked_get"); request.put ("hash", open->hash ().to_string ()); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (1, response.json.count ("contents")); - auto timestamp (response.json.get ("modified_timestamp")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (1, response.count ("contents")); + auto timestamp (response.get ("modified_timestamp")); ASSERT_LE (timestamp, nano::seconds_since_epoch ()); } request.put ("json_block", true); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & contents (response.json.get_child ("contents")); + auto response (wait_response (system, rpc, request)); + auto & contents (response.get_child ("contents")); ASSERT_EQ ("state", contents.get ("type")); - auto timestamp (response.json.get ("modified_timestamp")); + auto timestamp (response.get ("modified_timestamp")); ASSERT_LE (timestamp, nano::seconds_since_epoch ()); } } @@ -6398,57 +5063,40 @@ TEST (rpc, unchecked_get) TEST (rpc, unchecked_clear) { nano::system system; - auto & node = *add_ipc_enabled_node (system); + auto node = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node); nano::keypair key; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); auto open (std::make_shared (key.pub, 0, key.pub, 1, key.pub, key.prv, key.pub, *system.work.generate (key.pub))); - node.process_active (open); - node.block_processor.flush (); + node->process_active (open); + node->block_processor.flush (); boost::property_tree::ptree request; { - ASSERT_EQ (node.store.unchecked_count (node.store.tx_begin_read ()), 1); + ASSERT_EQ (node->store.unchecked.count (node->store.tx_begin_read ()), 1); } request.put ("action", "unchecked_clear"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); - ASSERT_TIMELY (10s, node.store.unchecked_count (node.store.tx_begin_read ()) == 0); + ASSERT_TIMELY (10s, node->store.unchecked.count (node->store.tx_begin_read ()) == 0); } TEST (rpc, unopened) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); nano::account account1 (1), account2 (account1.number () + 1); - auto genesis (node->latest (nano::dev_genesis_key.pub)); + auto genesis (node->latest (nano::dev::genesis_key.pub)); ASSERT_FALSE (genesis.is_zero ()); - auto send (system.wallet (0)->send_action (nano::dev_genesis_key.pub, account1, 1)); + auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, account1, 1)); ASSERT_NE (nullptr, send); - auto send2 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, account2, 10)); + auto send2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, account2, 10)); ASSERT_NE (nullptr, send2); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); { boost::property_tree::ptree request; request.put ("action", "unopened"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & accounts (response.json.get_child ("accounts")); + auto response (wait_response (system, rpc, request)); + auto & accounts (response.get_child ("accounts")); ASSERT_EQ (2, accounts.size ()); ASSERT_EQ ("1", accounts.get (account1.to_account ())); ASSERT_EQ ("10", accounts.get (account2.to_account ())); @@ -6458,10 +5106,8 @@ TEST (rpc, unopened) boost::property_tree::ptree request; request.put ("action", "unopened"); request.put ("account", account2.to_account ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & accounts (response.json.get_child ("accounts")); + auto response (wait_response (system, rpc, request)); + auto & accounts (response.get_child ("accounts")); ASSERT_EQ (1, accounts.size ()); ASSERT_EQ ("10", accounts.get (account2.to_account ())); } @@ -6470,10 +5116,8 @@ TEST (rpc, unopened) boost::property_tree::ptree request; request.put ("action", "unopened"); request.put ("account", nano::account (account2.number () + 1).to_account ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & accounts (response.json.get_child ("accounts")); + auto response (wait_response (system, rpc, request)); + auto & accounts (response.get_child ("accounts")); ASSERT_EQ (0, accounts.size ()); } { @@ -6481,10 +5125,8 @@ TEST (rpc, unopened) boost::property_tree::ptree request; request.put ("action", "unopened"); request.put ("count", "1"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & accounts (response.json.get_child ("accounts")); + auto response (wait_response (system, rpc, request)); + auto & accounts (response.get_child ("accounts")); ASSERT_EQ (1, accounts.size ()); ASSERT_EQ ("1", accounts.get (account1.to_account ())); } @@ -6493,10 +5135,8 @@ TEST (rpc, unopened) boost::property_tree::ptree request; request.put ("action", "unopened"); request.put ("threshold", 5); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & accounts (response.json.get_child ("accounts")); + auto response (wait_response (system, rpc, request)); + auto & accounts (response.get_child ("accounts")); ASSERT_EQ (1, accounts.size ()); ASSERT_EQ ("10", accounts.get (account2.to_account ())); } @@ -6506,25 +5146,16 @@ TEST (rpc, unopened_burn) { nano::system system; auto node = add_ipc_enabled_node (system); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto genesis (node->latest (nano::dev_genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto genesis (node->latest (nano::dev::genesis_key.pub)); ASSERT_FALSE (genesis.is_zero ()); - auto send (system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::burn_account, 1)); + auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::constants.burn_account, 1)); ASSERT_NE (nullptr, send); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "unopened"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & accounts (response.json.get_child ("accounts")); + auto response (wait_response (system, rpc, request)); + auto & accounts (response.get_child ("accounts")); ASSERT_EQ (0, accounts.size ()); } @@ -6532,20 +5163,11 @@ TEST (rpc, unopened_no_accounts) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "unopened"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & accounts (response.json.get_child ("accounts")); + auto response (wait_response (system, rpc, request)); + auto & accounts (response.get_child ("accounts")); ASSERT_EQ (0, accounts.size ()); } @@ -6553,57 +5175,42 @@ TEST (rpc, uptime) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "uptime"); std::this_thread::sleep_for (std::chrono::seconds (1)); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_LE (1, response.json.get ("seconds")); + auto response (wait_response (system, rpc, request)); + ASSERT_LE (1, response.get ("seconds")); } -TEST (rpc, wallet_history) +// Test disabled because it's failing intermittently. +// PR in which it got disabled: https://github.com/nanocurrency/nano-node/pull/3512 +// Issue for investigating it: https://github.com/nanocurrency/nano-node/issues/3514 +TEST (rpc, DISABLED_wallet_history) { nano::system system; nano::node_config node_config (nano::get_available_port (), system.logging); node_config.enable_voting = false; auto node = add_ipc_enabled_node (system, node_config); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto timestamp1 (nano::seconds_since_epoch ()); - auto send (system.wallet (0)->send_action (nano::dev_genesis_key.pub, nano::dev_genesis_key.pub, node->config.receive_minimum.number ())); + auto send (system.wallet (0)->send_action (nano::dev::genesis_key.pub, nano::dev::genesis_key.pub, node->config.receive_minimum.number ())); ASSERT_NE (nullptr, send); auto timestamp2 (nano::seconds_since_epoch ()); - auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev_genesis_key.pub, node->config.receive_minimum.number (), send->link ().as_account ())); + auto receive (system.wallet (0)->receive_action (send->hash (), nano::dev::genesis_key.pub, node->config.receive_minimum.number (), send->link ().as_account ())); ASSERT_NE (nullptr, receive); nano::keypair key; auto timestamp3 (nano::seconds_since_epoch ()); - auto send2 (system.wallet (0)->send_action (nano::dev_genesis_key.pub, key.pub, node->config.receive_minimum.number ())); + auto send2 (system.wallet (0)->send_action (nano::dev::genesis_key.pub, key.pub, node->config.receive_minimum.number ())); ASSERT_NE (nullptr, send2); system.deadline_set (10s); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "wallet_history"); request.put ("wallet", node->wallets.items.begin ()->first.to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::vector> history_l; - auto & history_node (response.json.get_child ("history")); + auto & history_node (response.get_child ("history")); for (auto i (history_node.begin ()), n (history_node.end ()); i != n; ++i) { history_l.push_back (std::make_tuple (i->second.get ("type"), i->second.get ("account"), i->second.get ("amount"), i->second.get ("hash"), i->second.get ("block_account"), i->second.get ("local_timestamp"))); @@ -6613,58 +5220,46 @@ TEST (rpc, wallet_history) ASSERT_EQ (key.pub.to_account (), std::get<1> (history_l[0])); ASSERT_EQ (node->config.receive_minimum.to_string_dec (), std::get<2> (history_l[0])); ASSERT_EQ (send2->hash ().to_string (), std::get<3> (history_l[0])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<4> (history_l[0])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<4> (history_l[0])); ASSERT_EQ (std::to_string (timestamp3), std::get<5> (history_l[0])); ASSERT_EQ ("receive", std::get<0> (history_l[1])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[1])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[1])); ASSERT_EQ (node->config.receive_minimum.to_string_dec (), std::get<2> (history_l[1])); ASSERT_EQ (receive->hash ().to_string (), std::get<3> (history_l[1])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<4> (history_l[1])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<4> (history_l[1])); ASSERT_EQ (std::to_string (timestamp2), std::get<5> (history_l[1])); ASSERT_EQ ("send", std::get<0> (history_l[2])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[2])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[2])); ASSERT_EQ (node->config.receive_minimum.to_string_dec (), std::get<2> (history_l[2])); ASSERT_EQ (send->hash ().to_string (), std::get<3> (history_l[2])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<4> (history_l[2])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<4> (history_l[2])); ASSERT_EQ (std::to_string (timestamp1), std::get<5> (history_l[2])); // Genesis block ASSERT_EQ ("receive", std::get<0> (history_l[3])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<1> (history_l[3])); - ASSERT_EQ (nano::genesis_amount.convert_to (), std::get<2> (history_l[3])); - ASSERT_EQ (nano::genesis_hash.to_string (), std::get<3> (history_l[3])); - ASSERT_EQ (nano::dev_genesis_key.pub.to_account (), std::get<4> (history_l[3])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<1> (history_l[3])); + ASSERT_EQ (nano::dev::constants.genesis_amount.convert_to (), std::get<2> (history_l[3])); + ASSERT_EQ (nano::dev::genesis->hash ().to_string (), std::get<3> (history_l[3])); + ASSERT_EQ (nano::dev::genesis_key.pub.to_account (), std::get<4> (history_l[3])); } TEST (rpc, sign_hash) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); + auto node1 = add_ipc_enabled_node (system); nano::keypair key; - nano::state_block send (nano::genesis_account, node1.latest (nano::dev_genesis_key.pub), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + nano::state_block send (nano::dev::genesis->account (), node1->latest (nano::dev::genesis_key.pub), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "sign"); request.put ("hash", send.hash ().to_string ()); request.put ("key", key.prv.to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request, 10s)); std::error_code ec (nano::error_rpc::sign_hash_disabled); - ASSERT_EQ (response.json.get ("error"), ec.message ()); - node_rpc_config.enable_sign_hash = true; - test_response response2 (request, rpc.config.port, system.io_ctx); - system.deadline_set (10s); - ASSERT_TIMELY (10s, response2.status != 0); - ASSERT_EQ (200, response2.status); + ASSERT_EQ (response.get ("error"), ec.message ()); + rpc_ctx->node_rpc_config->enable_sign_hash = true; + auto response2 (wait_response (system, rpc, request, 10s)); nano::signature signature; - std::string signature_text (response2.json.get ("signature")); + std::string signature_text (response2.get ("signature")); ASSERT_FALSE (signature.decode_hex (signature_text)); ASSERT_FALSE (nano::validate_message (key.pub, send.hash (), signature)); } @@ -6672,31 +5267,22 @@ TEST (rpc, sign_hash) TEST (rpc, sign_block) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); + auto node1 = add_ipc_enabled_node (system); nano::keypair key; system.wallet (0)->insert_adhoc (key.prv); - nano::state_block send (nano::genesis_account, node1.latest (nano::dev_genesis_key.pub), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + nano::state_block send (nano::dev::genesis->account (), node1->latest (nano::dev::genesis_key.pub), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); + auto [rpc, rpc_ctx] = add_rpc (system, node1); boost::property_tree::ptree request; request.put ("action", "sign"); std::string wallet; - node1.wallets.items.begin ()->first.encode_hex (wallet); + node1->wallets.items.begin ()->first.encode_hex (wallet); request.put ("wallet", wallet); request.put ("account", key.pub.to_account ()); std::string json; send.serialize_json (json); request.put ("block", json); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - auto contents (response.json.get ("block")); + auto response (wait_response (system, rpc, request, 10s)); + auto contents (response.get ("block")); boost::property_tree::ptree block_l; std::stringstream block_stream (contents); boost::property_tree::read_json (block_stream, block_l); @@ -6710,39 +5296,28 @@ TEST (rpc, memory_stats) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); + auto [rpc, rpc_ctx] = add_rpc (system, node); // Preliminary test adding to the vote uniquer and checking json output is correct nano::keypair key; auto block (std::make_shared (0, 0, 0, 0, 0, key.prv, key.pub, 0)); std::vector hashes; hashes.push_back (block->hash ()); - auto vote (std::make_shared (key.pub, key.prv, 0, hashes)); + auto vote (std::make_shared (key.pub, key.prv, 0, 0, hashes)); node->vote_uniquer.unique (vote); - rpc.start (); boost::property_tree::ptree request; request.put ("action", "stats"); request.put ("type", "objects"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); - ASSERT_EQ (response.json.get_child ("node").get_child ("vote_uniquer").get_child ("votes").get ("count"), "1"); + ASSERT_EQ (response.get_child ("node").get_child ("vote_uniquer").get_child ("votes").get ("count"), "1"); } request.put ("type", "database"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_TRUE (!response.json.empty ()); + auto response (wait_response (system, rpc, request)); + ASSERT_TRUE (!response.empty ()); } } @@ -6750,54 +5325,40 @@ TEST (rpc, block_confirmed) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "block_info"); request.put ("hash", "bad_hash1337"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_blocks::invalid_block_hash).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (std::error_code (nano::error_blocks::invalid_block_hash).message (), response.get ("error")); request.put ("hash", "0"); - test_response response1 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response1.status != 0); - ASSERT_EQ (200, response1.status); - ASSERT_EQ (std::error_code (nano::error_blocks::not_found).message (), response1.json.get ("error")); + auto response1 (wait_response (system, rpc, request)); + ASSERT_EQ (std::error_code (nano::error_blocks::not_found).message (), response1.get ("error")); - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); nano::keypair key; // Open an account directly in the ledger { auto transaction = node->store.tx_begin_write (); - nano::block_hash latest (node->latest (nano::dev_genesis_key.pub)); - nano::send_block send1 (latest, key.pub, 300, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); + nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); + nano::send_block send1 (latest, key.pub, 300, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send1).code); - nano::open_block open1 (send1.hash (), nano::genesis_account, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); + nano::open_block open1 (send1.hash (), nano::dev::genesis->account (), key.pub, key.prv, key.pub, *system.work.generate (key.pub)); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, open1).code); } - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->renew (); // This should not be confirmed - nano::block_hash latest (node->latest (nano::dev_genesis_key.pub)); + nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); request.put ("hash", latest.to_string ()); - test_response response2 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response2.status != 0); - - ASSERT_EQ (200, response2.status); - ASSERT_FALSE (response2.json.get ("confirmed")); + auto response2 (wait_response (system, rpc, request)); + ASSERT_FALSE (response2.get ("confirmed")); // Create and process a new send block - auto send = std::make_shared (latest, key.pub, 10, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); + auto send = std::make_shared (latest, key.pub, 10, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); node->process_active (send); node->block_processor.flush (); node->block_confirm (send); @@ -6810,15 +5371,13 @@ TEST (rpc, block_confirmed) // Requesting confirmation for this should now succeed request.put ("hash", send->hash ().to_string ()); - test_response response3 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response3.status != 0); - ASSERT_EQ (200, response3.status); - ASSERT_TRUE (response3.json.get ("confirmed")); + auto response3 (wait_response (system, rpc, request)); + ASSERT_TRUE (response3.get ("confirmed")); } TEST (rpc, database_txn_tracker) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; @@ -6828,23 +5387,14 @@ TEST (rpc, database_txn_tracker) { nano::system system; auto node = add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "database_txn_tracker"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request)); std::error_code ec (nano::error_common::tracking_not_enabled); - ASSERT_EQ (response.json.get ("error"), ec.message ()); + ASSERT_EQ (response.get ("error"), ec.message ()); } } @@ -6853,22 +5403,13 @@ TEST (rpc, database_txn_tracker) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.diagnostics_config.txn_tracking.enable = true; auto node = add_ipc_enabled_node (system, node_config); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; - auto check_not_correct_amount = [&system, &request, &rpc_port = rpc.config.port] () { - test_response response (request, rpc_port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); + auto check_not_correct_amount = [&system, &request, rpc = rpc] () { + auto response (wait_response (system, rpc, request)); std::error_code ec (nano::error_common::invalid_amount); - ASSERT_EQ (response.json.get ("error"), ec.message ()); + ASSERT_EQ (response.get ("error"), ec.message ()); }; request.put ("action", "database_txn_tracker"); @@ -6903,13 +5444,11 @@ TEST (rpc, database_txn_tracker) // Adjust minimum read time so that it can detect the read transaction being opened request.put ("min_read_time", "1000"); - test_response response (request, rpc.config.port, system.io_ctx); // It can take a long time to generate stack traces - ASSERT_TIMELY (60s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request, 60s)); keep_txn_alive_promise.set_value (); std::vector>>> json_l; - auto & json_node (response.json.get_child ("txn_tracking")); + auto & json_node (response.get_child ("txn_tracking")); for (auto & stat : json_node) { auto & stack_trace = stat.second.get_child ("stacktrace"); @@ -6938,53 +5477,43 @@ TEST (rpc, active_difficulty) { nano::system system; auto node = add_ipc_enabled_node (system); - ASSERT_EQ (node->default_difficulty (nano::work_version::work_1), node->network_params.network.publish_thresholds.epoch_2); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); + ASSERT_EQ (node->default_difficulty (nano::work_version::work_1), node->network_params.work.epoch_2); boost::property_tree::ptree request; request.put ("action", "active_difficulty"); auto expected_multiplier{ 1.0 }; { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto network_minimum_text (response.json.get ("network_minimum")); + auto response (wait_response (system, rpc, request)); + auto network_minimum_text (response.get ("network_minimum")); uint64_t network_minimum; ASSERT_FALSE (nano::from_string_hex (network_minimum_text, network_minimum)); ASSERT_EQ (node->default_difficulty (nano::work_version::work_1), network_minimum); - auto network_receive_minimum_text (response.json.get ("network_receive_minimum")); + auto network_receive_minimum_text (response.get ("network_receive_minimum")); uint64_t network_receive_minimum; ASSERT_FALSE (nano::from_string_hex (network_receive_minimum_text, network_receive_minimum)); ASSERT_EQ (node->default_receive_difficulty (nano::work_version::work_1), network_receive_minimum); - auto multiplier (response.json.get ("multiplier")); + auto multiplier (response.get ("multiplier")); ASSERT_NEAR (expected_multiplier, multiplier, 1e-6); - auto network_current_text (response.json.get ("network_current")); + auto network_current_text (response.get ("network_current")); uint64_t network_current; ASSERT_FALSE (nano::from_string_hex (network_current_text, network_current)); ASSERT_EQ (nano::difficulty::from_multiplier (expected_multiplier, node->default_difficulty (nano::work_version::work_1)), network_current); - auto network_receive_current_text (response.json.get ("network_receive_current")); + auto network_receive_current_text (response.get ("network_receive_current")); uint64_t network_receive_current; ASSERT_FALSE (nano::from_string_hex (network_receive_current_text, network_receive_current)); auto network_receive_current_multiplier (nano::difficulty::to_multiplier (network_receive_current, network_receive_minimum)); - auto network_receive_current_normalized_multiplier (nano::normalized_multiplier (network_receive_current_multiplier, network_receive_minimum)); + auto network_receive_current_normalized_multiplier (nano::dev::network_params.work.normalized_multiplier (network_receive_current_multiplier, network_receive_minimum)); ASSERT_NEAR (network_receive_current_normalized_multiplier, multiplier, 1e-6); - ASSERT_EQ (response.json.not_found (), response.json.find ("difficulty_trend")); + ASSERT_EQ (response.not_found (), response.find ("difficulty_trend")); } // Test include_trend optional request.put ("include_trend", true); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - auto trend_opt (response.json.get_child_optional ("difficulty_trend")); + auto response (wait_response (system, rpc, request)); + auto trend_opt (response.get_child_optional ("difficulty_trend")); ASSERT_TRUE (trend_opt.is_initialized ()); auto & trend (trend_opt.get ()); - ASSERT_EQ (0, trend.size ()); + ASSERT_EQ (1, trend.size ()); } } @@ -6998,7 +5527,7 @@ TEST (rpc, simultaneous_calls) nano::thread_runner runner (system.io_ctx, node->config.io_threads); nano::node_rpc_config node_rpc_config; nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); + nano::rpc_config rpc_config{ nano::dev::network_params.network, nano::get_available_port (), true }; rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; rpc_config.rpc_process.num_ipc_connections = 8; nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); @@ -7006,7 +5535,7 @@ TEST (rpc, simultaneous_calls) rpc.start (); boost::property_tree::ptree request; request.put ("action", "account_block_count"); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); constexpr auto num = 100; std::array, num> test_responses; @@ -7031,7 +5560,7 @@ TEST (rpc, simultaneous_calls) promise.get_future ().wait (); - ASSERT_TIMELY (60s, std::all_of (test_responses.begin (), test_responses.end (), [] (const auto & test_response) { return test_response->status != 0; })); + ASSERT_TIMELY (60s, std::all_of (test_responses.begin (), test_responses.end (), [] (auto const & test_response) { return test_response->status != 0; })); for (int i = 0; i < num; ++i) { @@ -7052,28 +5581,26 @@ TEST (rpc, in_process) nano::system system; auto node = add_ipc_enabled_node (system); scoped_io_thread_name_change scoped_thread_name_io; - nano::rpc_config rpc_config (nano::get_available_port (), true); + nano::rpc_config rpc_config (nano::dev::network_params.network, nano::get_available_port (), true); rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; nano::node_rpc_config node_rpc_config; nano::ipc::ipc_server ipc_server (*node, node_rpc_config); nano::inprocess_rpc_handler inprocess_rpc_handler (*node, ipc_server, node_rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, inprocess_rpc_handler); - rpc.start (); + auto rpc (std::make_shared (system.io_ctx, rpc_config, inprocess_rpc_handler)); + rpc->start (); boost::property_tree::ptree request; request.put ("action", "account_balance"); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - std::string balance_text (response.json.get ("balance")); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); + auto response (wait_response (system, rpc, request)); + std::string balance_text (response.get ("balance")); ASSERT_EQ ("340282366920938463463374607431768211455", balance_text); - std::string pending_text (response.json.get ("pending")); + std::string pending_text (response.get ("pending")); ASSERT_EQ ("0", pending_text); } TEST (rpc_config, serialization) { - nano::rpc_config config1; + nano::rpc_config config1{ nano::dev::network_params.network }; config1.address = boost::asio::ip::address_v6::any ().to_string (); config1.port = 10; config1.enable_control = true; @@ -7084,7 +5611,7 @@ TEST (rpc_config, serialization) config1.rpc_process.num_ipc_connections = 99; nano::jsonconfig tree; config1.serialize_json (tree); - nano::rpc_config config2; + nano::rpc_config config2{ nano::dev::network_params.network }; ASSERT_NE (config2.address, config1.address); ASSERT_NE (config2.port, config1.port); ASSERT_NE (config2.enable_control, config1.enable_control); @@ -7109,30 +5636,20 @@ TEST (rpc, deprecated_account_format) { nano::system system; auto node = add_ipc_enabled_node (system); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "account_info"); - request.put ("account", nano::dev_genesis_key.pub.to_account ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - boost::optional deprecated_account_format (response.json.get_optional ("deprecated_account_format")); + request.put ("account", nano::dev::genesis_key.pub.to_account ()); + auto response (wait_response (system, rpc, request)); + boost::optional deprecated_account_format (response.get_optional ("deprecated_account_format")); ASSERT_FALSE (deprecated_account_format.is_initialized ()); - std::string account_text (nano::dev_genesis_key.pub.to_account ()); + std::string account_text (nano::dev::genesis_key.pub.to_account ()); account_text[4] = '-'; request.put ("account", account_text); - test_response response2 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response2.status != 0); - ASSERT_EQ (200, response2.status); - std::string frontier (response.json.get ("frontier")); - ASSERT_EQ (nano::genesis_hash.to_string (), frontier); - boost::optional deprecated_account_format2 (response2.json.get_optional ("deprecated_account_format")); + auto response2 (wait_response (system, rpc, request)); + std::string frontier (response2.get ("frontier")); + ASSERT_EQ (nano::dev::genesis->hash ().to_string (), frontier); + boost::optional deprecated_account_format2 (response2.get_optional ("deprecated_account_format")); ASSERT_TRUE (deprecated_account_format2.is_initialized ()); } @@ -7141,68 +5658,57 @@ TEST (rpc, epoch_upgrade) nano::system system; auto node = add_ipc_enabled_node (system); nano::keypair key1, key2, key3; - nano::keypair epoch_signer (nano::dev_genesis_key); - auto send1 (std::make_shared (nano::dev_genesis_key.pub, nano::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - 1, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash))); // to opened account + nano::keypair epoch_signer (nano::dev::genesis_key); + auto send1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 1, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); // to opened account ASSERT_EQ (nano::process_result::progress, node->process (*send1).code); - auto send2 (std::make_shared (nano::dev_genesis_key.pub, send1->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 2, key2.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ()))); // to unopened account (pending) + auto send2 (std::make_shared (nano::dev::genesis_key.pub, send1->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 2, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()))); // to unopened account (pending) ASSERT_EQ (nano::process_result::progress, node->process (*send2).code); - auto send3 (std::make_shared (nano::dev_genesis_key.pub, send2->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 3, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send2->hash ()))); // to burn (0) + auto send3 (std::make_shared (nano::dev::genesis_key.pub, send2->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 3, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2->hash ()))); // to burn (0) ASSERT_EQ (nano::process_result::progress, node->process (*send3).code); nano::account max_account (std::numeric_limits::max ()); - auto send4 (std::make_shared (nano::dev_genesis_key.pub, send3->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 4, max_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send3->hash ()))); // to max account + auto send4 (std::make_shared (nano::dev::genesis_key.pub, send3->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 4, max_account, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3->hash ()))); // to max account ASSERT_EQ (nano::process_result::progress, node->process (*send4).code); auto open (std::make_shared (key1.pub, 0, key1.pub, 1, send1->hash (), key1.prv, key1.pub, *system.work.generate (key1.pub))); ASSERT_EQ (nano::process_result::progress, node->process (*open).code); // Check accounts epochs { auto transaction (node->store.tx_begin_read ()); - ASSERT_EQ (2, node->store.account_count (transaction)); - for (auto i (node->store.accounts_begin (transaction)); i != node->store.accounts_end (); ++i) + ASSERT_EQ (2, node->store.account.count (transaction)); + for (auto i (node->store.account.begin (transaction)); i != node->store.account.end (); ++i) { nano::account_info info (i->second); ASSERT_EQ (info.epoch (), nano::epoch::epoch_0); } } - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "epoch_upgrade"); request.put ("epoch", 1); request.put ("key", epoch_signer.prv.to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ ("1", response.json.get ("started")); - test_response response_fail (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response_fail.status != 0); - ASSERT_EQ (200, response_fail.status); - ASSERT_EQ ("0", response_fail.json.get ("started")); - ASSERT_TIMELY (10s, 4 == node->store.account_count (node->store.tx_begin_read ())); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ ("1", response.get ("started")); + ASSERT_TIMELY (10s, 4 == node->store.account.count (node->store.tx_begin_read ())); // Check upgrade { auto transaction (node->store.tx_begin_read ()); - ASSERT_EQ (4, node->store.account_count (transaction)); - for (auto i (node->store.accounts_begin (transaction)); i != node->store.accounts_end (); ++i) + ASSERT_EQ (4, node->store.account.count (transaction)); + for (auto i (node->store.account.begin (transaction)); i != node->store.account.end (); ++i) { nano::account_info info (i->second); ASSERT_EQ (info.epoch (), nano::epoch::epoch_1); } - ASSERT_TRUE (node->store.account_exists (transaction, key1.pub)); - ASSERT_TRUE (node->store.account_exists (transaction, key2.pub)); - ASSERT_TRUE (node->store.account_exists (transaction, std::numeric_limits::max ())); - ASSERT_FALSE (node->store.account_exists (transaction, 0)); + ASSERT_TRUE (node->store.account.exists (transaction, key1.pub)); + ASSERT_TRUE (node->store.account.exists (transaction, key2.pub)); + ASSERT_TRUE (node->store.account.exists (transaction, std::numeric_limits::max ())); + ASSERT_FALSE (node->store.account.exists (transaction, 0)); } + rpc_ctx->io_scope->reset (); // Epoch 2 upgrade - auto genesis_latest (node->latest (nano::dev_genesis_key.pub)); - auto send5 (std::make_shared (nano::dev_genesis_key.pub, genesis_latest, nano::dev_genesis_key.pub, nano::genesis_amount - 5, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (genesis_latest))); // to burn (0) + auto genesis_latest (node->latest (nano::dev::genesis_key.pub)); + auto send5 (std::make_shared (nano::dev::genesis_key.pub, genesis_latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 5, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis_latest))); // to burn (0) ASSERT_EQ (nano::process_result::progress, node->process (*send5).code); - auto send6 (std::make_shared (nano::dev_genesis_key.pub, send5->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 6, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send5->hash ()))); // to key1 (again) + auto send6 (std::make_shared (nano::dev::genesis_key.pub, send5->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 6, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send5->hash ()))); // to key1 (again) ASSERT_EQ (nano::process_result::progress, node->process (*send6).code); auto key1_latest (node->latest (key1.pub)); auto send7 (std::make_shared (key1.pub, key1_latest, key1.pub, 0, key3.pub, key1.prv, key1.pub, *system.work.generate (key1_latest))); // to key3 @@ -7211,30 +5717,29 @@ TEST (rpc, epoch_upgrade) // Check pending entry auto transaction (node->store.tx_begin_read ()); nano::pending_info info; - ASSERT_FALSE (node->store.pending_get (transaction, nano::pending_key (key3.pub, send7->hash ()), info)); + ASSERT_FALSE (node->store.pending.get (transaction, nano::pending_key (key3.pub, send7->hash ()), info)); ASSERT_EQ (nano::epoch::epoch_1, info.epoch); } + rpc_ctx->io_scope->renew (); request.put ("epoch", 2); - test_response response2 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response2.status != 0); - ASSERT_EQ (200, response2.status); - ASSERT_EQ ("1", response2.json.get ("started")); - ASSERT_TIMELY (10s, 5 == node->store.account_count (node->store.tx_begin_read ())); + auto response2 (wait_response (system, rpc, request)); + ASSERT_EQ ("1", response2.get ("started")); + ASSERT_TIMELY (10s, 5 == node->store.account.count (node->store.tx_begin_read ())); // Check upgrade { auto transaction (node->store.tx_begin_read ()); - ASSERT_EQ (5, node->store.account_count (transaction)); - for (auto i (node->store.accounts_begin (transaction)); i != node->store.accounts_end (); ++i) + ASSERT_EQ (5, node->store.account.count (transaction)); + for (auto i (node->store.account.begin (transaction)); i != node->store.account.end (); ++i) { nano::account_info info (i->second); ASSERT_EQ (info.epoch (), nano::epoch::epoch_2); } - ASSERT_TRUE (node->store.account_exists (transaction, key1.pub)); - ASSERT_TRUE (node->store.account_exists (transaction, key2.pub)); - ASSERT_TRUE (node->store.account_exists (transaction, key3.pub)); - ASSERT_TRUE (node->store.account_exists (transaction, std::numeric_limits::max ())); - ASSERT_FALSE (node->store.account_exists (transaction, 0)); + ASSERT_TRUE (node->store.account.exists (transaction, key1.pub)); + ASSERT_TRUE (node->store.account.exists (transaction, key2.pub)); + ASSERT_TRUE (node->store.account.exists (transaction, key3.pub)); + ASSERT_TRUE (node->store.account.exists (transaction, std::numeric_limits::max ())); + ASSERT_FALSE (node->store.account.exists (transaction, 0)); } } @@ -7245,65 +5750,58 @@ TEST (rpc, epoch_upgrade_multithreaded) node_config.work_threads = 4; auto node = add_ipc_enabled_node (system, node_config); nano::keypair key1, key2, key3; - nano::keypair epoch_signer (nano::dev_genesis_key); - auto send1 (std::make_shared (nano::dev_genesis_key.pub, nano::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - 1, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash))); // to opened account + nano::keypair epoch_signer (nano::dev::genesis_key); + auto send1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 1, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); // to opened account ASSERT_EQ (nano::process_result::progress, node->process (*send1).code); - auto send2 (std::make_shared (nano::dev_genesis_key.pub, send1->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 2, key2.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ()))); // to unopened account (pending) + auto send2 (std::make_shared (nano::dev::genesis_key.pub, send1->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 2, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()))); // to unopened account (pending) ASSERT_EQ (nano::process_result::progress, node->process (*send2).code); - auto send3 (std::make_shared (nano::dev_genesis_key.pub, send2->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 3, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send2->hash ()))); // to burn (0) + auto send3 (std::make_shared (nano::dev::genesis_key.pub, send2->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 3, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send2->hash ()))); // to burn (0) ASSERT_EQ (nano::process_result::progress, node->process (*send3).code); nano::account max_account (std::numeric_limits::max ()); - auto send4 (std::make_shared (nano::dev_genesis_key.pub, send3->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 4, max_account, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send3->hash ()))); // to max account + auto send4 (std::make_shared (nano::dev::genesis_key.pub, send3->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 4, max_account, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send3->hash ()))); // to max account ASSERT_EQ (nano::process_result::progress, node->process (*send4).code); auto open (std::make_shared (key1.pub, 0, key1.pub, 1, send1->hash (), key1.prv, key1.pub, *system.work.generate (key1.pub))); ASSERT_EQ (nano::process_result::progress, node->process (*open).code); // Check accounts epochs { auto transaction (node->store.tx_begin_read ()); - ASSERT_EQ (2, node->store.account_count (transaction)); - for (auto i (node->store.accounts_begin (transaction)); i != node->store.accounts_end (); ++i) + ASSERT_EQ (2, node->store.account.count (transaction)); + for (auto i (node->store.account.begin (transaction)); i != node->store.account.end (); ++i) { nano::account_info info (i->second); ASSERT_EQ (info.epoch (), nano::epoch::epoch_0); } } - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node->config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "epoch_upgrade"); request.put ("threads", 2); request.put ("epoch", 1); request.put ("key", epoch_signer.prv.to_string ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ ("1", response.json.get ("started")); - ASSERT_TIMELY (5s, 4 == node->store.account_count (node->store.tx_begin_read ())); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ ("1", response.get ("started")); + ASSERT_TIMELY (5s, 4 == node->store.account.count (node->store.tx_begin_read ())); // Check upgrade { auto transaction (node->store.tx_begin_read ()); - ASSERT_EQ (4, node->store.account_count (transaction)); - for (auto i (node->store.accounts_begin (transaction)); i != node->store.accounts_end (); ++i) + ASSERT_EQ (4, node->store.account.count (transaction)); + for (auto i (node->store.account.begin (transaction)); i != node->store.account.end (); ++i) { nano::account_info info (i->second); ASSERT_EQ (info.epoch (), nano::epoch::epoch_1); } - ASSERT_TRUE (node->store.account_exists (transaction, key1.pub)); - ASSERT_TRUE (node->store.account_exists (transaction, key2.pub)); - ASSERT_TRUE (node->store.account_exists (transaction, std::numeric_limits::max ())); - ASSERT_FALSE (node->store.account_exists (transaction, 0)); + ASSERT_TRUE (node->store.account.exists (transaction, key1.pub)); + ASSERT_TRUE (node->store.account.exists (transaction, key2.pub)); + ASSERT_TRUE (node->store.account.exists (transaction, std::numeric_limits::max ())); + ASSERT_FALSE (node->store.account.exists (transaction, 0)); } + rpc_ctx->io_scope->reset (); // Epoch 2 upgrade - auto genesis_latest (node->latest (nano::dev_genesis_key.pub)); - auto send5 (std::make_shared (nano::dev_genesis_key.pub, genesis_latest, nano::dev_genesis_key.pub, nano::genesis_amount - 5, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (genesis_latest))); // to burn (0) + auto genesis_latest (node->latest (nano::dev::genesis_key.pub)); + auto send5 (std::make_shared (nano::dev::genesis_key.pub, genesis_latest, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 5, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (genesis_latest))); // to burn (0) ASSERT_EQ (nano::process_result::progress, node->process (*send5).code); - auto send6 (std::make_shared (nano::dev_genesis_key.pub, send5->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - 6, key1.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send5->hash ()))); // to key1 (again) + auto send6 (std::make_shared (nano::dev::genesis_key.pub, send5->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - 6, key1.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send5->hash ()))); // to key1 (again) ASSERT_EQ (nano::process_result::progress, node->process (*send6).code); auto key1_latest (node->latest (key1.pub)); auto send7 (std::make_shared (key1.pub, key1_latest, key1.pub, 0, key3.pub, key1.prv, key1.pub, *system.work.generate (key1_latest))); // to key3 @@ -7312,30 +5810,29 @@ TEST (rpc, epoch_upgrade_multithreaded) // Check pending entry auto transaction (node->store.tx_begin_read ()); nano::pending_info info; - ASSERT_FALSE (node->store.pending_get (transaction, nano::pending_key (key3.pub, send7->hash ()), info)); + ASSERT_FALSE (node->store.pending.get (transaction, nano::pending_key (key3.pub, send7->hash ()), info)); ASSERT_EQ (nano::epoch::epoch_1, info.epoch); } + rpc_ctx->io_scope->renew (); request.put ("epoch", 2); - test_response response2 (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response2.status != 0); - ASSERT_EQ (200, response2.status); - ASSERT_EQ ("1", response2.json.get ("started")); - ASSERT_TIMELY (5s, 5 == node->store.account_count (node->store.tx_begin_read ())); + auto response2 (wait_response (system, rpc, request)); + ASSERT_EQ ("1", response2.get ("started")); + ASSERT_TIMELY (5s, 5 == node->store.account.count (node->store.tx_begin_read ())); // Check upgrade { auto transaction (node->store.tx_begin_read ()); - ASSERT_EQ (5, node->store.account_count (transaction)); - for (auto i (node->store.accounts_begin (transaction)); i != node->store.accounts_end (); ++i) + ASSERT_EQ (5, node->store.account.count (transaction)); + for (auto i (node->store.account.begin (transaction)); i != node->store.account.end (); ++i) { nano::account_info info (i->second); ASSERT_EQ (info.epoch (), nano::epoch::epoch_2); } - ASSERT_TRUE (node->store.account_exists (transaction, key1.pub)); - ASSERT_TRUE (node->store.account_exists (transaction, key2.pub)); - ASSERT_TRUE (node->store.account_exists (transaction, key3.pub)); - ASSERT_TRUE (node->store.account_exists (transaction, std::numeric_limits::max ())); - ASSERT_FALSE (node->store.account_exists (transaction, 0)); + ASSERT_TRUE (node->store.account.exists (transaction, key1.pub)); + ASSERT_TRUE (node->store.account.exists (transaction, key2.pub)); + ASSERT_TRUE (node->store.account.exists (transaction, key3.pub)); + ASSERT_TRUE (node->store.account.exists (transaction, std::numeric_limits::max ())); + ASSERT_FALSE (node->store.account.exists (transaction, 0)); } } @@ -7347,7 +5844,7 @@ TEST (rpc, account_lazy_start) auto node1 = system.add_node (node_flags); nano::keypair key; // Generating test chain - auto send1 (std::make_shared (nano::dev_genesis_key.pub, nano::genesis_hash, nano::dev_genesis_key.pub, nano::genesis_amount - nano::MBAN_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (nano::genesis_hash))); + auto send1 (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); ASSERT_EQ (nano::process_result::progress, node1->process (*send1).code); auto open (std::make_shared (send1->hash (), key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub))); ASSERT_EQ (nano::process_result::progress, node1->process (*open).code); @@ -7357,21 +5854,13 @@ TEST (rpc, account_lazy_start) node_config.ipc_config.transport_tcp.enabled = true; node_config.ipc_config.transport_tcp.port = nano::get_available_port (); auto node2 = system.add_node (node_config, node_flags); - node2->network.udp_channels.insert (node1->network.endpoint (), node1->network_params.protocol.protocol_version); - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (*node2, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node_config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + node2->network.udp_channels.insert (node1->network.endpoint (), node1->network_params.network.protocol_version); + auto [rpc, rpc_ctx] = add_rpc (system, node2); boost::property_tree::ptree request; request.put ("action", "account_info"); request.put ("account", key.pub.to_account ()); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - boost::optional account_error (response.json.get_optional ("error")); + auto response (wait_response (system, rpc, request)); + boost::optional account_error (response.get_optional ("error")); ASSERT_TRUE (account_error.is_initialized ()); // Check processed blocks @@ -7384,118 +5873,94 @@ TEST (rpc, account_lazy_start) TEST (rpc, receive) { nano::system system; - auto & node = *add_ipc_enabled_node (system); + auto node = add_ipc_enabled_node (system); auto wallet = system.wallet (0); std::string wallet_text; - node.wallets.items.begin ()->first.encode_hex (wallet_text); - wallet->insert_adhoc (nano::dev_genesis_key.prv); + node->wallets.items.begin ()->first.encode_hex (wallet_text); + wallet->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key1; wallet->insert_adhoc (key1.prv); - auto send1 (wallet->send_action (nano::dev_genesis_key.pub, key1.pub, node.config.receive_minimum.number (), *node.work_generate_blocking (nano::genesis_hash))); - ASSERT_TIMELY (5s, node.balance (nano::dev_genesis_key.pub) != nano::genesis_amount); - ASSERT_TIMELY (10s, !node.store.account_exists (node.store.tx_begin_read (), key1.pub)); + auto send1 (wallet->send_action (nano::dev::genesis_key.pub, key1.pub, node->config.receive_minimum.number (), *node->work_generate_blocking (nano::dev::genesis->hash ()))); + ASSERT_TIMELY (5s, node->balance (nano::dev::genesis_key.pub) != nano::dev::constants.genesis_amount); + ASSERT_TIMELY (10s, !node->store.account.exists (node->store.tx_begin_read (), key1.pub)); // Send below minimum receive amount - auto send2 (wallet->send_action (nano::dev_genesis_key.pub, key1.pub, node.config.receive_minimum.number () - 1, *node.work_generate_blocking (send1->hash ()))); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto send2 (wallet->send_action (nano::dev::genesis_key.pub, key1.pub, node->config.receive_minimum.number () - 1, *node->work_generate_blocking (send1->hash ()))); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receive"); request.put ("wallet", wallet_text); request.put ("account", key1.pub.to_account ()); request.put ("block", send2->hash ().to_string ()); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto receive_text (response.json.get ("block")); + auto response (wait_response (system, rpc, request)); + auto receive_text (response.get ("block")); nano::account_info info; - ASSERT_FALSE (node.store.account_get (node.store.tx_begin_read (), key1.pub, info)); - ASSERT_EQ (info.head, receive_text); + ASSERT_FALSE (node->store.account.get (node->store.tx_begin_read (), key1.pub, info)); + ASSERT_EQ (info.head, nano::block_hash{ receive_text }); } // Trying to receive the same block should fail with unreceivable { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_process::unreceivable).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (std::error_code (nano::error_process::unreceivable).message (), response.get ("error")); } // Trying to receive a non-existing block should fail request.put ("block", nano::block_hash (send2->hash ().number () + 1).to_string ()); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_blocks::not_found).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (std::error_code (nano::error_blocks::not_found).message (), response.get ("error")); } } TEST (rpc, receive_unopened) { nano::system system; - auto & node = *add_ipc_enabled_node (system); + auto node = add_ipc_enabled_node (system); auto wallet = system.wallet (0); std::string wallet_text; - node.wallets.items.begin ()->first.encode_hex (wallet_text); - wallet->insert_adhoc (nano::dev_genesis_key.prv); + node->wallets.items.begin ()->first.encode_hex (wallet_text); + wallet->insert_adhoc (nano::dev::genesis_key.prv); // Test receiving for unopened account nano::keypair key1; - auto send1 (wallet->send_action (nano::dev_genesis_key.pub, key1.pub, node.config.receive_minimum.number () - 1, *node.work_generate_blocking (nano::genesis_hash))); - ASSERT_TIMELY (5s, !node.balance (nano::dev_genesis_key.pub) != nano::genesis_amount); - ASSERT_FALSE (node.store.account_exists (node.store.tx_begin_read (), key1.pub)); - ASSERT_TRUE (node.store.block_exists (node.store.tx_begin_read (), send1->hash ())); + auto send1 (wallet->send_action (nano::dev::genesis_key.pub, key1.pub, node->config.receive_minimum.number () - 1, *node->work_generate_blocking (nano::dev::genesis->hash ()))); + ASSERT_TIMELY (5s, !node->balance (nano::dev::genesis_key.pub) != nano::dev::constants.genesis_amount); + ASSERT_FALSE (node->store.account.exists (node->store.tx_begin_read (), key1.pub)); + ASSERT_TRUE (node->store.block.exists (node->store.tx_begin_read (), send1->hash ())); wallet->insert_adhoc (key1.prv); // should not auto receive, amount sent was lower than minimum - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receive"); request.put ("wallet", wallet_text); request.put ("account", key1.pub.to_account ()); request.put ("block", send1->hash ().to_string ()); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto receive_text (response.json.get ("block")); + auto response (wait_response (system, rpc, request)); + auto receive_text (response.get ("block")); nano::account_info info; - ASSERT_FALSE (node.store.account_get (node.store.tx_begin_read (), key1.pub, info)); + ASSERT_FALSE (node->store.account.get (node->store.tx_begin_read (), key1.pub, info)); ASSERT_EQ (info.head, info.open_block); ASSERT_EQ (info.head.to_string (), receive_text); - ASSERT_EQ (info.representative, nano::dev_genesis_key.pub); + ASSERT_EQ (info.representative, nano::dev::genesis_key.pub); } - scoped_thread_name_io.reset (); + rpc_ctx->io_scope->reset (); // Test receiving for an unopened with a different wallet representative nano::keypair key2; - auto prev_amount (node.balance (nano::dev_genesis_key.pub)); - auto send2 (wallet->send_action (nano::dev_genesis_key.pub, key2.pub, node.config.receive_minimum.number () - 1, *node.work_generate_blocking (send1->hash ()))); - ASSERT_TIMELY (5s, !node.balance (nano::dev_genesis_key.pub) != prev_amount); - ASSERT_FALSE (node.store.account_exists (node.store.tx_begin_read (), key2.pub)); - ASSERT_TRUE (node.store.block_exists (node.store.tx_begin_read (), send2->hash ())); + auto prev_amount (node->balance (nano::dev::genesis_key.pub)); + auto send2 (wallet->send_action (nano::dev::genesis_key.pub, key2.pub, node->config.receive_minimum.number () - 1, *node->work_generate_blocking (send1->hash ()))); + ASSERT_TIMELY (5s, !node->balance (nano::dev::genesis_key.pub) != prev_amount); + ASSERT_FALSE (node->store.account.exists (node->store.tx_begin_read (), key2.pub)); + ASSERT_TRUE (node->store.block.exists (node->store.tx_begin_read (), send2->hash ())); nano::public_key rep; - wallet->store.representative_set (node.wallets.tx_begin_write (), rep); + wallet->store.representative_set (node->wallets.tx_begin_write (), rep); wallet->insert_adhoc (key2.prv); // should not auto receive, amount sent was lower than minimum - scoped_thread_name_io.renew (); + rpc_ctx->io_scope->renew (); request.put ("account", key2.pub.to_account ()); request.put ("block", send2->hash ().to_string ()); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto receive_text (response.json.get ("block")); + auto response (wait_response (system, rpc, request)); + auto receive_text (response.get ("block")); nano::account_info info; - ASSERT_FALSE (node.store.account_get (node.store.tx_begin_read (), key2.pub, info)); + ASSERT_FALSE (node->store.account.get (node->store.tx_begin_read (), key2.pub, info)); ASSERT_EQ (info.head, info.open_block); ASSERT_EQ (info.head.to_string (), receive_text); ASSERT_EQ (info.representative, rep); @@ -7509,38 +5974,28 @@ TEST (rpc, receive_work_disabled) auto & worker_node = *system.add_node (config); config.peering_port = nano::get_available_port (); config.work_threads = 0; - auto & node = *add_ipc_enabled_node (system, config); + auto node = add_ipc_enabled_node (system, config); auto wallet = system.wallet (1); std::string wallet_text; - node.wallets.items.begin ()->first.encode_hex (wallet_text); - wallet->insert_adhoc (nano::dev_genesis_key.prv); + node->wallets.items.begin ()->first.encode_hex (wallet_text); + wallet->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key1; - nano::genesis genesis; ASSERT_TRUE (worker_node.work_generation_enabled ()); - auto send1 (wallet->send_action (nano::dev_genesis_key.pub, key1.pub, node.config.receive_minimum.number () - 1, *worker_node.work_generate_blocking (genesis.hash ()), false)); + auto send1 (wallet->send_action (nano::dev::genesis_key.pub, key1.pub, node->config.receive_minimum.number () - 1, *worker_node.work_generate_blocking (nano::dev::genesis->hash ()), false)); ASSERT_TRUE (send1 != nullptr); - ASSERT_TIMELY (5s, node.balance (nano::dev_genesis_key.pub) != nano::genesis_amount); - ASSERT_FALSE (node.store.account_exists (node.store.tx_begin_read (), key1.pub)); - ASSERT_TRUE (node.store.block_exists (node.store.tx_begin_read (), send1->hash ())); + ASSERT_TIMELY (5s, node->balance (nano::dev::genesis_key.pub) != nano::dev::constants.genesis_amount); + ASSERT_FALSE (node->store.account.exists (node->store.tx_begin_read (), key1.pub)); + ASSERT_TRUE (node->store.block.exists (node->store.tx_begin_read (), send1->hash ())); wallet->insert_adhoc (key1.prv); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node); boost::property_tree::ptree request; request.put ("action", "receive"); request.put ("wallet", wallet_text); request.put ("account", key1.pub.to_account ()); request.put ("block", send1->hash ().to_string ()); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_common::disabled_work_generation).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (std::error_code (nano::error_common::disabled_work_generation).message (), response.get ("error")); } } @@ -7552,89 +6007,69 @@ TEST (rpc, receive_pruned) node_config.enable_voting = false; // Remove after allowing pruned voting nano::node_flags node_flags; node_flags.enable_pruning = true; - auto & node2 = *add_ipc_enabled_node (system, node_config, node_flags); + auto node2 = add_ipc_enabled_node (system, node_config, node_flags); auto wallet1 = system.wallet (0); auto wallet2 = system.wallet (1); std::string wallet_text; - node2.wallets.items.begin ()->first.encode_hex (wallet_text); - wallet1->insert_adhoc (nano::dev_genesis_key.prv); + node2->wallets.items.begin ()->first.encode_hex (wallet_text); + wallet1->insert_adhoc (nano::dev::genesis_key.prv); nano::keypair key1; wallet2->insert_adhoc (key1.prv); - auto send1 (wallet1->send_action (nano::dev_genesis_key.pub, key1.pub, node2.config.receive_minimum.number (), *node2.work_generate_blocking (nano::genesis_hash))); - ASSERT_TIMELY (5s, node2.balance (nano::dev_genesis_key.pub) != nano::genesis_amount); - ASSERT_TIMELY (10s, !node2.store.account_exists (node2.store.tx_begin_read (), key1.pub)); + auto send1 (wallet1->send_action (nano::dev::genesis_key.pub, key1.pub, node2->config.receive_minimum.number (), *node2->work_generate_blocking (nano::dev::genesis->hash ()))); + ASSERT_TIMELY (5s, node2->balance (nano::dev::genesis_key.pub) != nano::dev::constants.genesis_amount); + ASSERT_TIMELY (10s, !node2->store.account.exists (node2->store.tx_begin_read (), key1.pub)); // Send below minimum receive amount - auto send2 (wallet1->send_action (nano::dev_genesis_key.pub, key1.pub, node2.config.receive_minimum.number () - 1, *node2.work_generate_blocking (send1->hash ()))); + auto send2 (wallet1->send_action (nano::dev::genesis_key.pub, key1.pub, node2->config.receive_minimum.number () - 1, *node2->work_generate_blocking (send1->hash ()))); // Extra send frontier - auto send3 (wallet1->send_action (nano::dev_genesis_key.pub, key1.pub, node2.config.receive_minimum.number (), *node2.work_generate_blocking (send1->hash ()))); + auto send3 (wallet1->send_action (nano::dev::genesis_key.pub, key1.pub, node2->config.receive_minimum.number (), *node2->work_generate_blocking (send1->hash ()))); // Pruning - ASSERT_TIMELY (5s, node2.ledger.cache.cemented_count == 6 && node2.confirmation_height_processor.current ().is_zero () && node2.confirmation_height_processor.awaiting_processing_size () == 0); + ASSERT_TIMELY (5s, node2->ledger.cache.cemented_count == 6 && node2->confirmation_height_processor.current ().is_zero () && node2->confirmation_height_processor.awaiting_processing_size () == 0); { - auto transaction (node2.store.tx_begin_write ()); - ASSERT_EQ (2, node2.ledger.pruning_action (transaction, send2->hash (), 1)); + auto transaction (node2->store.tx_begin_write ()); + ASSERT_EQ (2, node2->ledger.pruning_action (transaction, send2->hash (), 1)); } - ASSERT_EQ (2, node2.ledger.cache.pruned_count); - ASSERT_TRUE (node2.ledger.block_or_pruned_exists (send1->hash ())); - ASSERT_FALSE (node2.store.block_exists (node2.store.tx_begin_read (), send1->hash ())); - ASSERT_TRUE (node2.ledger.block_or_pruned_exists (send2->hash ())); - ASSERT_FALSE (node2.store.block_exists (node2.store.tx_begin_read (), send2->hash ())); - ASSERT_TRUE (node2.ledger.block_or_pruned_exists (send3->hash ())); + ASSERT_EQ (2, node2->ledger.cache.pruned_count); + ASSERT_TRUE (node2->ledger.block_or_pruned_exists (send1->hash ())); + ASSERT_FALSE (node2->store.block.exists (node2->store.tx_begin_read (), send1->hash ())); + ASSERT_TRUE (node2->ledger.block_or_pruned_exists (send2->hash ())); + ASSERT_FALSE (node2->store.block.exists (node2->store.tx_begin_read (), send2->hash ())); + ASSERT_TRUE (node2->ledger.block_or_pruned_exists (send3->hash ())); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node2, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node2.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto [rpc, rpc_ctx] = add_rpc (system, node2); boost::property_tree::ptree request; request.put ("action", "receive"); request.put ("wallet", wallet_text); request.put ("account", key1.pub.to_account ()); request.put ("block", send2->hash ().to_string ()); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto receive_text (response.json.get ("block")); + auto response (wait_response (system, rpc, request)); + auto receive_text (response.get ("block")); nano::account_info info; - ASSERT_FALSE (node2.store.account_get (node2.store.tx_begin_read (), key1.pub, info)); - ASSERT_EQ (info.head, receive_text); + ASSERT_FALSE (node2->store.account.get (node2->store.tx_begin_read (), key1.pub, info)); + ASSERT_EQ (info.head, nano::block_hash{ receive_text }); } // Trying to receive the same block should fail with unreceivable { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_process::unreceivable).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (std::error_code (nano::error_process::unreceivable).message (), response.get ("error")); } // Trying to receive a non-existing block should fail request.put ("block", nano::block_hash (send2->hash ().number () + 1).to_string ()); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_blocks::not_found).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (std::error_code (nano::error_blocks::not_found).message (), response.get ("error")); } } TEST (rpc, telemetry_single) { nano::system system (1); - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); // Wait until peers are stored as they are done in the background auto peers_stored = false; - ASSERT_TIMELY (10s, node1.store.peer_count (node1.store.tx_begin_read ()) != 0); + ASSERT_TIMELY (10s, node1->store.peer.count (node1->store.tx_begin_read ()) != 0); // Missing port boost::property_tree::ptree request; @@ -7643,10 +6078,8 @@ TEST (rpc, telemetry_single) request.put ("address", "not_a_valid_address"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_rpc::requires_port_and_address).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request, 10s)); + ASSERT_EQ (std::error_code (nano::error_rpc::requires_port_and_address).message (), response.get ("error")); } // Missing address @@ -7654,10 +6087,8 @@ TEST (rpc, telemetry_single) request.put ("port", 65); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_rpc::requires_port_and_address).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request, 10s)); + ASSERT_EQ (std::error_code (nano::error_rpc::requires_port_and_address).message (), response.get ("error")); } // Try with invalid address @@ -7665,30 +6096,24 @@ TEST (rpc, telemetry_single) request.put ("port", 65); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_common::invalid_ip_address).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request, 10s)); + ASSERT_EQ (std::error_code (nano::error_common::invalid_ip_address).message (), response.get ("error")); } // Then invalid port request.put ("address", (boost::format ("%1%") % node->network.endpoint ().address ()).str ()); request.put ("port", "invalid port"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_common::invalid_port).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request, 10s)); + ASSERT_EQ (std::error_code (nano::error_common::invalid_port).message (), response.get ("error")); } // Use correctly formed address and port request.put ("port", node->network.endpoint ().port ()); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request, 10s)); - nano::jsonconfig config (response.json); + nano::jsonconfig config (response); nano::telemetry_data telemetry_data; auto const should_ignore_identification_metrics = false; ASSERT_FALSE (telemetry_data.deserialize_json (config, should_ignore_identification_metrics)); @@ -7699,23 +6124,16 @@ TEST (rpc, telemetry_single) TEST (rpc, telemetry_all) { nano::system system (1); - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); // Wait until peers are stored as they are done in the background - ASSERT_TIMELY (10s, node1.store.peer_count (node1.store.tx_begin_read ()) != 0); + ASSERT_TIMELY (10s, node1->store.peer.count (node1->store.tx_begin_read ()) != 0); // First need to set up the cached data std::atomic done{ false }; auto node = system.nodes.front (); - node1.telemetry->get_metrics_single_peer_async (node1.network.find_channel (node->network.endpoint ()), [&done] (nano::telemetry_data_response const & telemetry_data_response_a) { + node1->telemetry->get_metrics_single_peer_async (node1->network.find_channel (node->network.endpoint ()), [&done] (nano::telemetry_data_response const & telemetry_data_response_a) { ASSERT_FALSE (telemetry_data_response_a.error); done = true; }); @@ -7725,24 +6143,21 @@ TEST (rpc, telemetry_all) boost::property_tree::ptree request; request.put ("action", "telemetry"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - nano::jsonconfig config (response.json); + auto response (wait_response (system, rpc, request, 10s)); + nano::jsonconfig config (response); nano::telemetry_data telemetry_data; auto const should_ignore_identification_metrics = true; ASSERT_FALSE (telemetry_data.deserialize_json (config, should_ignore_identification_metrics)); nano::compare_default_telemetry_response_data_excluding_signature (telemetry_data, node->network_params, node->config.bandwidth_limit, node->default_difficulty (nano::work_version::work_1)); - ASSERT_FALSE (response.json.get_optional ("node_id").is_initialized ()); - ASSERT_FALSE (response.json.get_optional ("signature").is_initialized ()); + ASSERT_FALSE (response.get_optional ("node_id").is_initialized ()); + ASSERT_FALSE (response.get_optional ("signature").is_initialized ()); } request.put ("raw", "true"); - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request, 10s)); // This may fail if the response has taken longer than the cache cutoff time. - auto & all_metrics = response.json.get_child ("metrics"); + auto & all_metrics = response.get_child ("metrics"); auto & metrics = all_metrics.front ().second; ASSERT_EQ (1, all_metrics.size ()); @@ -7754,70 +6169,55 @@ TEST (rpc, telemetry_all) ASSERT_EQ (node->network.endpoint ().address ().to_string (), metrics.get ("address")); ASSERT_EQ (node->network.endpoint ().port (), metrics.get ("port")); - ASSERT_TRUE (node1.network.find_node_id (data.node_id)); + ASSERT_TRUE (node1->network.find_node_id (data.node_id)); } // Also tests all forms of ipv4/ipv6 TEST (rpc, telemetry_self) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); // Just to have peer count at 1 - node1.network.udp_channels.insert (nano::endpoint (boost::asio::ip::make_address_v6 ("::1"), nano::get_available_port ()), 0); + node1->network.udp_channels.insert (nano::endpoint (boost::asio::ip::make_address_v6 ("::1"), nano::get_available_port ()), 0); boost::property_tree::ptree request; request.put ("action", "telemetry"); request.put ("address", "::1"); - request.put ("port", node1.network.endpoint ().port ()); + request.put ("port", node1->network.endpoint ().port ()); auto const should_ignore_identification_metrics = false; { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request, 10s)); nano::telemetry_data data; - nano::jsonconfig config (response.json); + nano::jsonconfig config (response); ASSERT_FALSE (data.deserialize_json (config, should_ignore_identification_metrics)); - nano::compare_default_telemetry_response_data (data, node1.network_params, node1.config.bandwidth_limit, node1.default_difficulty (nano::work_version::work_1), node1.node_id); + nano::compare_default_telemetry_response_data (data, node1->network_params, node1->config.bandwidth_limit, node1->default_difficulty (nano::work_version::work_1), node1->node_id); } request.put ("address", "[::1]"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request, 10s)); nano::telemetry_data data; - nano::jsonconfig config (response.json); + nano::jsonconfig config (response); ASSERT_FALSE (data.deserialize_json (config, should_ignore_identification_metrics)); - nano::compare_default_telemetry_response_data (data, node1.network_params, node1.config.bandwidth_limit, node1.default_difficulty (nano::work_version::work_1), node1.node_id); + nano::compare_default_telemetry_response_data (data, node1->network_params, node1->config.bandwidth_limit, node1->default_difficulty (nano::work_version::work_1), node1->node_id); } request.put ("address", "127.0.0.1"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); + auto response (wait_response (system, rpc, request, 10s)); nano::telemetry_data data; - nano::jsonconfig config (response.json); + nano::jsonconfig config (response); ASSERT_FALSE (data.deserialize_json (config, should_ignore_identification_metrics)); - nano::compare_default_telemetry_response_data (data, node1.network_params, node1.config.bandwidth_limit, node1.default_difficulty (nano::work_version::work_1), node1.node_id); + nano::compare_default_telemetry_response_data (data, node1->network_params, node1->config.bandwidth_limit, node1->default_difficulty (nano::work_version::work_1), node1->node_id); } // Incorrect port should fail request.put ("port", "0"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (10s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (std::error_code (nano::error_rpc::peer_not_found).message (), response.json.get ("error")); + auto response (wait_response (system, rpc, request, 10s)); + ASSERT_EQ (std::error_code (nano::error_rpc::peer_not_found).message (), response.get ("error")); } } @@ -7829,60 +6229,42 @@ TEST (rpc, confirmation_active) node_config.ipc_config.transport_tcp.port = nano::get_available_port (); nano::node_flags node_flags; node_flags.disable_request_loop = true; - auto & node1 (*system.add_node (node_config, node_flags)); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); - - nano::genesis genesis; - auto send1 (std::make_shared (genesis.hash (), nano::public_key (), nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (genesis.hash ()))); - auto send2 (std::make_shared (send1->hash (), nano::public_key (), nano::genesis_amount - 200, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send1->hash ()))); - node1.process_active (send1); - node1.process_active (send2); - nano::blocks_confirm (node1, { send1, send2 }); - ASSERT_EQ (2, node1.active.size ()); - auto election (node1.active.election (send1->qualified_root ())); + auto node1 (system.add_node (node_config, node_flags)); + auto [rpc, rpc_ctx] = add_rpc (system, node1); + + auto send1 (std::make_shared (nano::dev::genesis->hash (), nano::public_key (), nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); + auto send2 (std::make_shared (send1->hash (), nano::public_key (), nano::dev::constants.genesis_amount - 200, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send1->hash ()))); + node1->process_active (send1); + node1->process_active (send2); + nano::blocks_confirm (*node1, { send1, send2 }); + ASSERT_EQ (2, node1->active.size ()); + auto election (node1->active.election (send1->qualified_root ())); ASSERT_NE (nullptr, election); election->force_confirm (); boost::property_tree::ptree request; request.put ("action", "confirmation_active"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - auto & confirmations (response.json.get_child ("confirmations")); + auto response (wait_response (system, rpc, request)); + auto & confirmations (response.get_child ("confirmations")); ASSERT_EQ (1, confirmations.size ()); ASSERT_EQ (send2->qualified_root ().to_string (), confirmations.front ().second.get ("")); - ASSERT_EQ (1, response.json.get ("unconfirmed")); - ASSERT_EQ (1, response.json.get ("confirmed")); + ASSERT_EQ (1, response.get ("unconfirmed")); + ASSERT_EQ (1, response.get ("confirmed")); } } TEST (rpc, confirmation_info) { nano::system system; - auto & node1 = *add_ipc_enabled_node (system); - scoped_io_thread_name_change scoped_thread_name_io; - nano::node_rpc_config node_rpc_config; - nano::ipc::ipc_server ipc_server (node1, node_rpc_config); - nano::rpc_config rpc_config (nano::get_available_port (), true); - rpc_config.rpc_process.ipc_port = node1.config.ipc_config.transport_tcp.port; - nano::ipc_rpc_processor ipc_rpc_processor (system.io_ctx, rpc_config); - nano::rpc rpc (system.io_ctx, rpc_config, ipc_rpc_processor); - rpc.start (); + auto node1 = add_ipc_enabled_node (system); + auto [rpc, rpc_ctx] = add_rpc (system, node1); - nano::genesis genesis; - auto send (std::make_shared (genesis.hash (), nano::public_key (), nano::genesis_amount - 100, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (genesis.hash ()))); - node1.process_active (send); - node1.block_processor.flush (); - node1.scheduler.flush (); - ASSERT_FALSE (node1.active.empty ()); + auto send (std::make_shared (nano::dev::genesis->hash (), nano::public_key (), nano::dev::constants.genesis_amount - 100, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ()))); + node1->process_active (send); + node1->block_processor.flush (); + node1->scheduler.flush (); + ASSERT_FALSE (node1->active.empty ()); boost::property_tree::ptree request; request.put ("action", "confirmation_info"); @@ -7890,16 +6272,14 @@ TEST (rpc, confirmation_info) request.put ("representatives", "true"); request.put ("json_block", "true"); { - test_response response (request, rpc.config.port, system.io_ctx); - ASSERT_TIMELY (5s, response.status != 0); - ASSERT_EQ (200, response.status); - ASSERT_EQ (1, response.json.count ("announcements")); - ASSERT_EQ (1, response.json.get ("voters")); - ASSERT_EQ (send->hash ().to_string (), response.json.get ("last_winner")); - auto & blocks (response.json.get_child ("blocks")); + auto response (wait_response (system, rpc, request)); + ASSERT_EQ (1, response.count ("announcements")); + ASSERT_EQ (1, response.get ("voters")); + ASSERT_EQ (send->hash ().to_string (), response.get ("last_winner")); + auto & blocks (response.get_child ("blocks")); ASSERT_EQ (1, blocks.size ()); auto & representatives (blocks.front ().second.get_child ("representatives")); ASSERT_EQ (1, representatives.size ()); - ASSERT_EQ (0, response.json.get ("total_tally")); + ASSERT_EQ (0, response.get ("total_tally")); } } diff --git a/nano/secure/CMakeLists.txt b/nano/secure/CMakeLists.txt index 4bcdabe9c4..e55d8982cd 100644 --- a/nano/secure/CMakeLists.txt +++ b/nano/secure/CMakeLists.txt @@ -39,9 +39,9 @@ add_library( ${PLATFORM_SECURE_SOURCE} ${CMAKE_BINARY_DIR}/bootstrap_weights_live.cpp ${CMAKE_BINARY_DIR}/bootstrap_weights_beta.cpp - blockstore.hpp - blockstore.cpp - blockstore_partial.hpp + store.hpp + store.cpp + store_partial.hpp buffer.hpp common.hpp common.cpp @@ -53,7 +53,18 @@ add_library( utility.cpp versioning.hpp versioning.cpp - working.hpp) + working.hpp + store/block_store_partial.hpp + store/frontier_store_partial.hpp + store/account_store_partial.hpp + store/pending_store_partial.hpp + store/online_weight_partial.hpp + store/pruned_store_partial.hpp + store/peer_store_partial.hpp + store/confirmation_height_store_partial.hpp + store/unchecked_store_partial.hpp + store/final_vote_store_partial.hpp + store/version_store_partial.hpp) target_link_libraries( secure diff --git a/nano/secure/blockstore_partial.hpp b/nano/secure/blockstore_partial.hpp deleted file mode 100644 index 3250cb61c5..0000000000 --- a/nano/secure/blockstore_partial.hpp +++ /dev/null @@ -1,1002 +0,0 @@ -#pragma once - -#include -#include -#include -#include -#include -#include - -#include - -#include - -#define release_assert_success(status) \ - if (!success (status)) \ - { \ - release_assert (false, error_string (status)); \ - } -namespace -{ -template -void parallel_traversal (std::function const & action); -} - -namespace nano -{ -template -class block_predecessor_set; - -/** This base class implements the block_store interface functions which have DB agnostic functionality */ -template -class block_store_partial : public block_store -{ -public: - using block_store::block_exists; - using block_store::unchecked_put; - - friend class nano::block_predecessor_set; - - /** - * If using a different store version than the latest then you may need - * to modify some of the objects in the store to be appropriate for the version before an upgrade. - */ - void initialize (nano::write_transaction const & transaction_a, nano::genesis const & genesis_a, nano::ledger_cache & ledger_cache_a) override - { - auto hash_l (genesis_a.hash ()); - debug_assert (accounts_begin (transaction_a) == accounts_end ()); - genesis_a.open->sideband_set (nano::block_sideband (network_params.ledger.genesis_account, 0, network_params.ledger.genesis_amount, 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); - block_put (transaction_a, hash_l, *genesis_a.open); - ++ledger_cache_a.block_count; - confirmation_height_put (transaction_a, network_params.ledger.genesis_account, nano::confirmation_height_info{ 1, genesis_a.hash () }); - ++ledger_cache_a.cemented_count; - ledger_cache_a.final_votes_confirmation_canary = (network_params.ledger.final_votes_canary_account == network_params.ledger.genesis_account && 1 >= network_params.ledger.final_votes_canary_height); - account_put (transaction_a, network_params.ledger.genesis_account, { hash_l, network_params.ledger.genesis_account, genesis_a.open->hash (), std::numeric_limits::max (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0 }); - ++ledger_cache_a.account_count; - ledger_cache_a.rep_weights.representation_put (network_params.ledger.genesis_account, std::numeric_limits::max ()); - frontier_put (transaction_a, hash_l, network_params.ledger.genesis_account); - } - - void block_put (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a, nano::block const & block_a) override - { - debug_assert (block_a.sideband ().successor.is_zero () || block_exists (transaction_a, block_a.sideband ().successor)); - std::vector vector; - { - nano::vectorstream stream (vector); - nano::serialize_block (stream, block_a); - block_a.sideband ().serialize (stream, block_a.type ()); - } - block_raw_put (transaction_a, vector, hash_a); - nano::block_predecessor_set predecessor (transaction_a, *this); - block_a.visit (predecessor); - debug_assert (block_a.previous ().is_zero () || block_successor (transaction_a, block_a.previous ()) == hash_a); - } - - // Converts a block hash to a block height - uint64_t block_account_height (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override - { - auto block = block_get (transaction_a, hash_a); - return block->sideband ().height; - } - - nano::uint128_t block_balance (nano::transaction const & transaction_a, nano::block_hash const & hash_a) override - { - auto block (block_get (transaction_a, hash_a)); - release_assert (block); - nano::uint128_t result (block_balance_calculated (block)); - return result; - } - - std::shared_ptr block_get (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override - { - auto value (block_raw_get (transaction_a, hash_a)); - std::shared_ptr result; - if (value.size () != 0) - { - nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); - nano::block_type type; - auto error (try_read (stream, type)); - release_assert (!error); - result = nano::deserialize_block (stream, type); - release_assert (result != nullptr); - nano::block_sideband sideband; - error = (sideband.deserialize (stream, type)); - release_assert (!error); - result->sideband_set (sideband); - } - return result; - } - - bool block_exists (nano::transaction const & transaction_a, nano::block_hash const & hash_a) override - { - auto junk = block_raw_get (transaction_a, hash_a); - return junk.size () != 0; - } - - std::shared_ptr block_get_no_sideband (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override - { - auto value (block_raw_get (transaction_a, hash_a)); - std::shared_ptr result; - if (value.size () != 0) - { - nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); - result = nano::deserialize_block (stream); - debug_assert (result != nullptr); - } - return result; - } - - bool root_exists (nano::transaction const & transaction_a, nano::root const & root_a) override - { - return block_exists (transaction_a, root_a.as_block_hash ()) || account_exists (transaction_a, root_a.as_account ()); - } - - nano::account block_account (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override - { - auto block (block_get (transaction_a, hash_a)); - debug_assert (block != nullptr); - return block_account_calculated (*block); - } - - nano::account block_account_calculated (nano::block const & block_a) const override - { - debug_assert (block_a.has_sideband ()); - nano::account result (block_a.account ()); - if (result.is_zero ()) - { - result = block_a.sideband ().account; - } - debug_assert (!result.is_zero ()); - return result; - } - - nano::uint128_t block_balance_calculated (std::shared_ptr const & block_a) const override - { - nano::uint128_t result; - switch (block_a->type ()) - { - case nano::block_type::open: - case nano::block_type::receive: - case nano::block_type::change: - result = block_a->sideband ().balance.number (); - break; - case nano::block_type::send: - result = boost::polymorphic_downcast (block_a.get ())->hashables.balance.number (); - break; - case nano::block_type::state: - result = boost::polymorphic_downcast (block_a.get ())->hashables.balance.number (); - break; - case nano::block_type::invalid: - case nano::block_type::not_a_block: - release_assert (false); - break; - } - return result; - } - - nano::block_hash block_successor (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override - { - auto value (block_raw_get (transaction_a, hash_a)); - nano::block_hash result; - if (value.size () != 0) - { - debug_assert (value.size () >= result.bytes.size ()); - auto type = block_type_from_raw (value.data ()); - nano::bufferstream stream (reinterpret_cast (value.data ()) + block_successor_offset (transaction_a, value.size (), type), result.bytes.size ()); - auto error (nano::try_read (stream, result.bytes)); - (void)error; - debug_assert (!error); - } - else - { - result.clear (); - } - return result; - } - - void block_successor_clear (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a) override - { - auto value (block_raw_get (transaction_a, hash_a)); - debug_assert (value.size () != 0); - auto type = block_type_from_raw (value.data ()); - std::vector data (static_cast (value.data ()), static_cast (value.data ()) + value.size ()); - std::fill_n (data.begin () + block_successor_offset (transaction_a, value.size (), type), sizeof (nano::block_hash), uint8_t{ 0 }); - block_raw_put (transaction_a, data, hash_a); - } - - nano::store_iterator unchecked_end () const override - { - return nano::store_iterator (nullptr); - } - - nano::store_iterator peers_end () const override - { - return nano::store_iterator (nullptr); - } - - nano::store_iterator pending_end () const override - { - return nano::store_iterator (nullptr); - } - - nano::store_iterator online_weight_end () const override - { - return nano::store_iterator (nullptr); - } - - nano::store_iterator accounts_end () const override - { - return nano::store_iterator (nullptr); - } - - nano::store_iterator blocks_end () const override - { - return nano::store_iterator (nullptr); - } - - nano::store_iterator confirmation_height_end () const override - { - return nano::store_iterator (nullptr); - } - - nano::store_iterator pruned_end () const override - { - return nano::store_iterator (nullptr); - } - - nano::store_iterator final_vote_end () const override - { - return nano::store_iterator (nullptr); - } - - nano::store_iterator frontiers_end () const override - { - return nano::store_iterator (nullptr); - } - - int version_get (nano::transaction const & transaction_a) const override - { - nano::uint256_union version_key (1); - nano::db_val data; - auto status = get (transaction_a, tables::meta, nano::db_val (version_key), data); - int result (minimum_version); - if (success (status)) - { - nano::uint256_union version_value (data); - debug_assert (version_value.qwords[2] == 0 && version_value.qwords[1] == 0 && version_value.qwords[0] == 0); - result = version_value.number ().convert_to (); - } - return result; - } - - void block_del (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a) override - { - auto status = del (transaction_a, tables::blocks, hash_a); - release_assert_success (status); - } - - nano::epoch block_version (nano::transaction const & transaction_a, nano::block_hash const & hash_a) override - { - auto block = block_get (transaction_a, hash_a); - if (block && block->type () == nano::block_type::state) - { - return block->sideband ().details.epoch; - } - - return nano::epoch::epoch_0; - } - - void block_raw_put (nano::write_transaction const & transaction_a, std::vector const & data, nano::block_hash const & hash_a) override - { - nano::db_val value{ data.size (), (void *)data.data () }; - auto status = put (transaction_a, tables::blocks, hash_a, value); - release_assert_success (status); - } - - void pending_put (nano::write_transaction const & transaction_a, nano::pending_key const & key_a, nano::pending_info const & pending_info_a) override - { - nano::db_val pending (pending_info_a); - auto status = put (transaction_a, tables::pending, key_a, pending); - release_assert_success (status); - } - - void pending_del (nano::write_transaction const & transaction_a, nano::pending_key const & key_a) override - { - auto status = del (transaction_a, tables::pending, key_a); - release_assert_success (status); - } - - bool pending_get (nano::transaction const & transaction_a, nano::pending_key const & key_a, nano::pending_info & pending_a) override - { - nano::db_val value; - nano::db_val key (key_a); - auto status1 = get (transaction_a, tables::pending, key, value); - release_assert (success (status1) || not_found (status1)); - bool result (true); - if (success (status1)) - { - nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); - result = pending_a.deserialize (stream); - } - return result; - } - - bool pending_exists (nano::transaction const & transaction_a, nano::pending_key const & key_a) override - { - auto iterator (pending_begin (transaction_a, key_a)); - return iterator != pending_end () && nano::pending_key (iterator->first) == key_a; - } - - bool pending_any (nano::transaction const & transaction_a, nano::account const & account_a) override - { - auto iterator (pending_begin (transaction_a, nano::pending_key (account_a, 0))); - return iterator != pending_end () && nano::pending_key (iterator->first).account == account_a; - } - - void frontier_put (nano::write_transaction const & transaction_a, nano::block_hash const & block_a, nano::account const & account_a) override - { - nano::db_val account (account_a); - auto status (put (transaction_a, tables::frontiers, block_a, account)); - release_assert_success (status); - } - - nano::account frontier_get (nano::transaction const & transaction_a, nano::block_hash const & block_a) const override - { - nano::db_val value; - auto status (get (transaction_a, tables::frontiers, nano::db_val (block_a), value)); - release_assert (success (status) || not_found (status)); - nano::account result (0); - if (success (status)) - { - result = static_cast (value); - } - return result; - } - - void frontier_del (nano::write_transaction const & transaction_a, nano::block_hash const & block_a) override - { - auto status (del (transaction_a, tables::frontiers, block_a)); - release_assert_success (status); - } - - void unchecked_put (nano::write_transaction const & transaction_a, nano::unchecked_key const & key_a, nano::unchecked_info const & info_a) override - { - nano::db_val info (info_a); - auto status (put (transaction_a, tables::unchecked, key_a, info)); - release_assert_success (status); - } - - void unchecked_del (nano::write_transaction const & transaction_a, nano::unchecked_key const & key_a) override - { - auto status (del (transaction_a, tables::unchecked, key_a)); - release_assert_success (status); - } - - bool unchecked_exists (nano::transaction const & transaction_a, nano::unchecked_key const & unchecked_key_a) override - { - nano::db_val value; - auto status (get (transaction_a, tables::unchecked, nano::db_val (unchecked_key_a), value)); - release_assert (success (status) || not_found (status)); - return (success (status)); - } - - void unchecked_put (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a, std::shared_ptr const & block_a) override - { - nano::unchecked_key key (hash_a, block_a->hash ()); - nano::unchecked_info info (block_a, block_a->account (), nano::seconds_since_epoch (), nano::signature_verification::unknown); - unchecked_put (transaction_a, key, info); - } - - void unchecked_clear (nano::write_transaction const & transaction_a) override - { - auto status = drop (transaction_a, tables::unchecked); - release_assert_success (status); - } - - void account_put (nano::write_transaction const & transaction_a, nano::account const & account_a, nano::account_info const & info_a) override - { - // Check we are still in sync with other tables - nano::db_val info (info_a); - auto status = put (transaction_a, tables::accounts, account_a, info); - release_assert_success (status); - } - - void account_del (nano::write_transaction const & transaction_a, nano::account const & account_a) override - { - auto status = del (transaction_a, tables::accounts, account_a); - release_assert_success (status); - } - - bool account_get (nano::transaction const & transaction_a, nano::account const & account_a, nano::account_info & info_a) override - { - nano::db_val value; - nano::db_val account (account_a); - auto status1 (get (transaction_a, tables::accounts, account, value)); - release_assert (success (status1) || not_found (status1)); - bool result (true); - if (success (status1)) - { - nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); - result = info_a.deserialize (stream); - } - return result; - } - - bool account_exists (nano::transaction const & transaction_a, nano::account const & account_a) override - { - auto iterator (accounts_begin (transaction_a, account_a)); - return iterator != accounts_end () && nano::account (iterator->first) == account_a; - } - - void online_weight_put (nano::write_transaction const & transaction_a, uint64_t time_a, nano::amount const & amount_a) override - { - nano::db_val value (amount_a); - auto status (put (transaction_a, tables::online_weight, time_a, value)); - release_assert_success (status); - } - - void online_weight_del (nano::write_transaction const & transaction_a, uint64_t time_a) override - { - auto status (del (transaction_a, tables::online_weight, time_a)); - release_assert_success (status); - } - - size_t online_weight_count (nano::transaction const & transaction_a) const override - { - return count (transaction_a, tables::online_weight); - } - - void online_weight_clear (nano::write_transaction const & transaction_a) override - { - auto status (drop (transaction_a, tables::online_weight)); - release_assert_success (status); - } - - void pruned_put (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a) override - { - auto status = put_key (transaction_a, tables::pruned, hash_a); - release_assert_success (status); - } - - void pruned_del (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a) override - { - auto status = del (transaction_a, tables::pruned, hash_a); - release_assert_success (status); - } - - bool pruned_exists (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override - { - return exists (transaction_a, tables::pruned, nano::db_val (hash_a)); - } - - size_t pruned_count (nano::transaction const & transaction_a) const override - { - return count (transaction_a, tables::pruned); - } - - void pruned_clear (nano::write_transaction const & transaction_a) override - { - auto status = drop (transaction_a, tables::pruned); - release_assert_success (status); - } - - void peer_put (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) override - { - auto status = put_key (transaction_a, tables::peers, endpoint_a); - release_assert_success (status); - } - - void peer_del (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) override - { - auto status (del (transaction_a, tables::peers, endpoint_a)); - release_assert_success (status); - } - - bool peer_exists (nano::transaction const & transaction_a, nano::endpoint_key const & endpoint_a) const override - { - return exists (transaction_a, tables::peers, nano::db_val (endpoint_a)); - } - - size_t peer_count (nano::transaction const & transaction_a) const override - { - return count (transaction_a, tables::peers); - } - - void peer_clear (nano::write_transaction const & transaction_a) override - { - auto status = drop (transaction_a, tables::peers); - release_assert_success (status); - } - - bool exists (nano::transaction const & transaction_a, tables table_a, nano::db_val const & key_a) const - { - return static_cast (*this).exists (transaction_a, table_a, key_a); - } - - uint64_t block_count (nano::transaction const & transaction_a) override - { - return count (transaction_a, tables::blocks); - } - - size_t account_count (nano::transaction const & transaction_a) override - { - return count (transaction_a, tables::accounts); - } - - std::shared_ptr block_random (nano::transaction const & transaction_a) override - { - nano::block_hash hash; - nano::random_pool::generate_block (hash.bytes.data (), hash.bytes.size ()); - auto existing = make_iterator> (transaction_a, tables::blocks, nano::db_val (hash)); - auto end (nano::store_iterator> (nullptr)); - if (existing == end) - { - existing = make_iterator> (transaction_a, tables::blocks); - } - debug_assert (existing != end); - return existing->second; - } - - nano::block_hash pruned_random (nano::transaction const & transaction_a) override - { - nano::block_hash random_hash; - nano::random_pool::generate_block (random_hash.bytes.data (), random_hash.bytes.size ()); - auto existing = make_iterator> (transaction_a, tables::pruned, nano::db_val (random_hash)); - auto end (nano::store_iterator> (nullptr)); - if (existing == end) - { - existing = make_iterator> (transaction_a, tables::pruned); - } - return existing != end ? existing->first : 0; - } - - uint64_t confirmation_height_count (nano::transaction const & transaction_a) override - { - return count (transaction_a, tables::confirmation_height); - } - - void confirmation_height_put (nano::write_transaction const & transaction_a, nano::account const & account_a, nano::confirmation_height_info const & confirmation_height_info_a) override - { - nano::db_val confirmation_height_info (confirmation_height_info_a); - auto status = put (transaction_a, tables::confirmation_height, account_a, confirmation_height_info); - release_assert_success (status); - } - - bool confirmation_height_get (nano::transaction const & transaction_a, nano::account const & account_a, nano::confirmation_height_info & confirmation_height_info_a) override - { - nano::db_val value; - auto status = get (transaction_a, tables::confirmation_height, nano::db_val (account_a), value); - release_assert (success (status) || not_found (status)); - bool result (true); - if (success (status)) - { - nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); - result = confirmation_height_info_a.deserialize (stream); - } - if (result) - { - confirmation_height_info_a.height = 0; - confirmation_height_info_a.frontier = 0; - } - - return result; - } - - void confirmation_height_del (nano::write_transaction const & transaction_a, nano::account const & account_a) override - { - auto status (del (transaction_a, tables::confirmation_height, nano::db_val (account_a))); - release_assert_success (status); - } - - bool confirmation_height_exists (nano::transaction const & transaction_a, nano::account const & account_a) const override - { - return exists (transaction_a, tables::confirmation_height, nano::db_val (account_a)); - } - - bool final_vote_put (nano::write_transaction const & transaction_a, nano::qualified_root const & root_a, nano::block_hash const & hash_a) override - { - nano::db_val value; - auto status = get (transaction_a, tables::final_votes, nano::db_val (root_a), value); - release_assert (success (status) || not_found (status)); - bool result (true); - if (success (status)) - { - result = static_cast (value) == hash_a; - } - else - { - status = put (transaction_a, tables::final_votes, root_a, hash_a); - release_assert_success (status); - } - return result; - } - - std::vector final_vote_get (nano::transaction const & transaction_a, nano::root const & root_a) override - { - std::vector result; - nano::qualified_root key_start (root_a.raw, 0); - for (auto i (final_vote_begin (transaction_a, key_start)), n (final_vote_end ()); i != n && nano::qualified_root (i->first).root () == root_a; ++i) - { - result.push_back (i->second); - } - return result; - } - - size_t final_vote_count (nano::transaction const & transaction_a) const override - { - return count (transaction_a, tables::final_votes); - } - - void final_vote_del (nano::write_transaction const & transaction_a, nano::root const & root_a) override - { - std::vector final_vote_qualified_roots; - for (auto i (final_vote_begin (transaction_a, nano::qualified_root (root_a.raw, 0))), n (final_vote_end ()); i != n && nano::qualified_root (i->first).root () == root_a; ++i) - { - final_vote_qualified_roots.push_back (i->first); - } - - for (auto & final_vote_qualified_root : final_vote_qualified_roots) - { - auto status (del (transaction_a, tables::final_votes, nano::db_val (final_vote_qualified_root))); - release_assert_success (status); - } - } - - void final_vote_clear (nano::write_transaction const & transaction_a, nano::root const & root_a) override - { - final_vote_del (transaction_a, root_a); - } - - void final_vote_clear (nano::write_transaction const & transaction_a) override - { - drop (transaction_a, nano::tables::final_votes); - } - - void confirmation_height_clear (nano::write_transaction const & transaction_a, nano::account const & account_a) override - { - confirmation_height_del (transaction_a, account_a); - } - - void confirmation_height_clear (nano::write_transaction const & transaction_a) override - { - drop (transaction_a, nano::tables::confirmation_height); - } - - nano::store_iterator accounts_begin (nano::transaction const & transaction_a, nano::account const & account_a) const override - { - return make_iterator (transaction_a, tables::accounts, nano::db_val (account_a)); - } - - nano::store_iterator accounts_begin (nano::transaction const & transaction_a) const override - { - return make_iterator (transaction_a, tables::accounts); - } - - nano::store_iterator blocks_begin (nano::transaction const & transaction_a) const override - { - return make_iterator (transaction_a, tables::blocks); - } - - nano::store_iterator blocks_begin (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override - { - return make_iterator (transaction_a, tables::blocks, nano::db_val (hash_a)); - } - - nano::store_iterator frontiers_begin (nano::transaction const & transaction_a) const override - { - return make_iterator (transaction_a, tables::frontiers); - } - - nano::store_iterator frontiers_begin (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override - { - return make_iterator (transaction_a, tables::frontiers, nano::db_val (hash_a)); - } - - nano::store_iterator pending_begin (nano::transaction const & transaction_a, nano::pending_key const & key_a) const override - { - return make_iterator (transaction_a, tables::pending, nano::db_val (key_a)); - } - - nano::store_iterator pending_begin (nano::transaction const & transaction_a) const override - { - return make_iterator (transaction_a, tables::pending); - } - - nano::store_iterator unchecked_begin (nano::transaction const & transaction_a) const override - { - return make_iterator (transaction_a, tables::unchecked); - } - - nano::store_iterator unchecked_begin (nano::transaction const & transaction_a, nano::unchecked_key const & key_a) const override - { - return make_iterator (transaction_a, tables::unchecked, nano::db_val (key_a)); - } - - nano::store_iterator online_weight_begin (nano::transaction const & transaction_a) const override - { - return make_iterator (transaction_a, tables::online_weight); - } - - nano::store_iterator peers_begin (nano::transaction const & transaction_a) const override - { - return make_iterator (transaction_a, tables::peers); - } - - nano::store_iterator confirmation_height_begin (nano::transaction const & transaction_a, nano::account const & account_a) const override - { - return make_iterator (transaction_a, tables::confirmation_height, nano::db_val (account_a)); - } - - nano::store_iterator confirmation_height_begin (nano::transaction const & transaction_a) const override - { - return make_iterator (transaction_a, tables::confirmation_height); - } - - nano::store_iterator pruned_begin (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override - { - return make_iterator (transaction_a, tables::pruned, nano::db_val (hash_a)); - } - - nano::store_iterator pruned_begin (nano::transaction const & transaction_a) const override - { - return make_iterator (transaction_a, tables::pruned); - } - - nano::store_iterator final_vote_begin (nano::transaction const & transaction_a, nano::qualified_root const & root_a) const override - { - return make_iterator (transaction_a, tables::final_votes, nano::db_val (root_a)); - } - - nano::store_iterator final_vote_begin (nano::transaction const & transaction_a) const override - { - return make_iterator (transaction_a, tables::final_votes); - } - - nano::store_iterator accounts_rbegin (nano::transaction const & transaction_a) const override - { - return make_iterator (transaction_a, tables::accounts, false); - } - - nano::store_iterator online_weight_rbegin (nano::transaction const & transaction_a) const override - { - return make_iterator (transaction_a, tables::online_weight, false); - } - - size_t unchecked_count (nano::transaction const & transaction_a) override - { - return count (transaction_a, tables::unchecked); - } - - void accounts_for_each_par (std::function, nano::store_iterator)> const & action_a) const override - { - parallel_traversal ( - [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { - auto transaction (this->tx_begin_read ()); - action_a (transaction, this->accounts_begin (transaction, start), !is_last ? this->accounts_begin (transaction, end) : this->accounts_end ()); - }); - } - - void confirmation_height_for_each_par (std::function, nano::store_iterator)> const & action_a) const override - { - parallel_traversal ( - [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { - auto transaction (this->tx_begin_read ()); - action_a (transaction, this->confirmation_height_begin (transaction, start), !is_last ? this->confirmation_height_begin (transaction, end) : this->confirmation_height_end ()); - }); - } - - void pending_for_each_par (std::function, nano::store_iterator)> const & action_a) const override - { - parallel_traversal ( - [&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) { - nano::uint512_union union_start (start); - nano::uint512_union union_end (end); - nano::pending_key key_start (union_start.uint256s[0].number (), union_start.uint256s[1].number ()); - nano::pending_key key_end (union_end.uint256s[0].number (), union_end.uint256s[1].number ()); - auto transaction (this->tx_begin_read ()); - action_a (transaction, this->pending_begin (transaction, key_start), !is_last ? this->pending_begin (transaction, key_end) : this->pending_end ()); - }); - } - - void unchecked_for_each_par (std::function, nano::store_iterator)> const & action_a) const override - { - parallel_traversal ( - [&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) { - nano::unchecked_key key_start (start); - nano::unchecked_key key_end (end); - auto transaction (this->tx_begin_read ()); - action_a (transaction, this->unchecked_begin (transaction, key_start), !is_last ? this->unchecked_begin (transaction, key_end) : this->unchecked_end ()); - }); - } - - void blocks_for_each_par (std::function, nano::store_iterator)> const & action_a) const override - { - parallel_traversal ( - [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { - auto transaction (this->tx_begin_read ()); - action_a (transaction, this->blocks_begin (transaction, start), !is_last ? this->blocks_begin (transaction, end) : this->blocks_end ()); - }); - } - - void pruned_for_each_par (std::function, nano::store_iterator)> const & action_a) const override - { - parallel_traversal ( - [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { - auto transaction (this->tx_begin_read ()); - action_a (transaction, this->pruned_begin (transaction, start), !is_last ? this->pruned_begin (transaction, end) : this->pruned_end ()); - }); - } - - void frontiers_for_each_par (std::function, nano::store_iterator)> const & action_a) const override - { - parallel_traversal ( - [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { - auto transaction (this->tx_begin_read ()); - action_a (transaction, this->frontiers_begin (transaction, start), !is_last ? this->frontiers_begin (transaction, end) : this->frontiers_end ()); - }); - } - - void final_vote_for_each_par (std::function, nano::store_iterator)> const & action_a) const override - { - parallel_traversal ( - [&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) { - auto transaction (this->tx_begin_read ()); - action_a (transaction, this->final_vote_begin (transaction, start), !is_last ? this->final_vote_begin (transaction, end) : this->final_vote_end ()); - }); - } - - int const minimum_version{ 14 }; - -protected: - nano::network_params network_params; - int const version{ 21 }; - - template - nano::store_iterator make_iterator (nano::transaction const & transaction_a, tables table_a, bool const direction_asc = true) const - { - return static_cast (*this).template make_iterator (transaction_a, table_a, direction_asc); - } - - template - nano::store_iterator make_iterator (nano::transaction const & transaction_a, tables table_a, nano::db_val const & key) const - { - return static_cast (*this).template make_iterator (transaction_a, table_a, key); - } - - nano::db_val block_raw_get (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const - { - nano::db_val result; - auto status = get (transaction_a, tables::blocks, hash_a, result); - release_assert (success (status) || not_found (status)); - return result; - } - - size_t block_successor_offset (nano::transaction const & transaction_a, size_t entry_size_a, nano::block_type type_a) const - { - return entry_size_a - nano::block_sideband::size (type_a); - } - - static nano::block_type block_type_from_raw (void * data_a) - { - // The block type is the first byte - return static_cast ((reinterpret_cast (data_a))[0]); - } - - uint64_t count (nano::transaction const & transaction_a, std::initializer_list dbs_a) const - { - uint64_t total_count = 0; - for (auto db : dbs_a) - { - total_count += count (transaction_a, db); - } - return total_count; - } - - int get (nano::transaction const & transaction_a, tables table_a, nano::db_val const & key_a, nano::db_val & value_a) const - { - return static_cast (*this).get (transaction_a, table_a, key_a, value_a); - } - - int put (nano::write_transaction const & transaction_a, tables table_a, nano::db_val const & key_a, nano::db_val const & value_a) - { - return static_cast (*this).put (transaction_a, table_a, key_a, value_a); - } - - // Put only key without value - int put_key (nano::write_transaction const & transaction_a, tables table_a, nano::db_val const & key_a) - { - return put (transaction_a, table_a, key_a, nano::db_val{ nullptr }); - } - - int del (nano::write_transaction const & transaction_a, tables table_a, nano::db_val const & key_a) - { - return static_cast (*this).del (transaction_a, table_a, key_a); - } - - virtual uint64_t count (nano::transaction const & transaction_a, tables table_a) const = 0; - virtual int drop (nano::write_transaction const & transaction_a, tables table_a) = 0; - virtual bool not_found (int status) const = 0; - virtual bool success (int status) const = 0; - virtual int status_code_not_found () const = 0; - virtual std::string error_string (int status) const = 0; -}; - -/** - * Fill in our predecessors - */ -template -class block_predecessor_set : public nano::block_visitor -{ -public: - block_predecessor_set (nano::write_transaction const & transaction_a, nano::block_store_partial & store_a) : - transaction (transaction_a), - store (store_a) - { - } - virtual ~block_predecessor_set () = default; - void fill_value (nano::block const & block_a) - { - auto hash (block_a.hash ()); - auto value (store.block_raw_get (transaction, block_a.previous ())); - debug_assert (value.size () != 0); - auto type = store.block_type_from_raw (value.data ()); - std::vector data (static_cast (value.data ()), static_cast (value.data ()) + value.size ()); - std::copy (hash.bytes.begin (), hash.bytes.end (), data.begin () + store.block_successor_offset (transaction, value.size (), type)); - store.block_raw_put (transaction, data, block_a.previous ()); - } - void send_block (nano::send_block const & block_a) override - { - fill_value (block_a); - } - void receive_block (nano::receive_block const & block_a) override - { - fill_value (block_a); - } - void open_block (nano::open_block const & block_a) override - { - // Open blocks don't have a predecessor - } - void change_block (nano::change_block const & block_a) override - { - fill_value (block_a); - } - void state_block (nano::state_block const & block_a) override - { - if (!block_a.previous ().is_zero ()) - { - fill_value (block_a); - } - } - nano::write_transaction const & transaction; - nano::block_store_partial & store; -}; -} - -namespace -{ -template -void parallel_traversal (std::function const & action) -{ - // Between 10 and 40 threads, scales well even in low power systems as long as actions are I/O bound - unsigned const thread_count = std::max (10u, std::min (40u, 10 * std::thread::hardware_concurrency ())); - T const value_max{ std::numeric_limits::max () }; - T const split = value_max / thread_count; - std::vector threads; - threads.reserve (thread_count); - for (unsigned thread (0); thread < thread_count; ++thread) - { - T const start = thread * split; - T const end = (thread + 1) * split; - bool const is_last = thread == thread_count - 1; - - threads.emplace_back ([&action, start, end, is_last] { - nano::thread_role::set (nano::thread_role::name::db_parallel_traversal); - action (start, end, is_last); - }); - } - for (auto & thread : threads) - { - thread.join (); - } -} -} diff --git a/nano/secure/common.cpp b/nano/secure/common.cpp index a3db37a54d..ca431f061f 100644 --- a/nano/secure/common.cpp +++ b/nano/secure/common.cpp @@ -1,8 +1,9 @@ #include #include #include -#include +#include #include +#include #include @@ -21,7 +22,7 @@ size_t constexpr nano::open_block::size; size_t constexpr nano::change_block::size; size_t constexpr nano::state_block::size; -nano::nano_networks nano::network_constants::active_network = nano::nano_networks::ACTIVE_NETWORK; +nano::networks nano::network_constants::active_network = nano::networks::ACTIVE_NETWORK; namespace { @@ -37,7 +38,7 @@ char const * dev_genesis_data = R"%%%({ "account": "ban_3e3j5tkog48pnny9dmfzj1r16pg8t1e76dz5tmac6iq689wyjfpiij4txtdo", "work": "7b42a00ee91d5810", "signature": "ECDA914373A2F0CA1296475BAEE40500A7F0A7AD72A5A80C81D7FAB7F6C802B2CC7DB50F5DD0FB25B2EF11761FA7344A158DD5A700B21BD47DE5BD0F63153A02" - })%%%"; + })%%%"; char const * beta_genesis_data = R"%%%({ "type": "open", @@ -46,7 +47,7 @@ char const * beta_genesis_data = R"%%%({ "account": "bano_1betagoxpxwykx4kw86dnhosc8t3s7ix8eeentwkcg1hbpez1outjrcyg4n1", "work": "79d4e27dc873c6f2", "signature": "4BD7F96F9ED2721BCEE5EAED400EA50AD00524C629AE55E9AFF11220D2C1B00C3D4B3BB770BF67D4F8658023B677F91110193B6C101C2666931F57046A6DB806" - })%%%"; + })%%%"; char const * live_genesis_data = R"%%%({ "type": "open", @@ -55,7 +56,7 @@ char const * live_genesis_data = R"%%%({ "account": "ban_1bananobh5rat99qfgt1ptpieie5swmoth87thi74qgbfrij7dcgjiij94xr", "work": "fa055f79fa56abcf", "signature": "533DCAB343547B93C4128E779848DEA5877D3278CB5EA948BB3A9AA1AE0DB293DE6D9DA4F69E8D1DDFA385F9B4C5E4F38DFA42C00D7B183560435D07AFA18900" - })%%%"; + })%%%"; std::string const test_genesis_data = nano::get_env_or_default ("NANO_TEST_GENESIS_BLOCK", R"%%%({ "type": "open", @@ -64,7 +65,7 @@ std::string const test_genesis_data = nano::get_env_or_default ("NANO_TEST_GENES "account": "bano_1jg8zygjg3pp5w644emqcbmjqpnzmubfni3kfe1s8pooeuxsw49fdq1mco9j", "work": "bc1ef279c1a34eb1", "signature": "15049467CAEE3EC768639E8E35792399B6078DA763DA4EBA8ECAD33B0EDC4AF2E7403893A5A602EB89B978DABEF1D6606BB00F3C0EE11449232B143B6E07170E" - })%%%"); + })%%%"); std::shared_ptr parse_block_from_genesis_data (std::string const & genesis_data_a) { @@ -74,78 +75,93 @@ std::shared_ptr parse_block_from_genesis_data (std::string const & return nano::deserialize_block_json (tree); } -char const * beta_canary_public_key_data = "868C6A9F79D4506E029B378262B91538C5CB26D7C346B63902FFEB365F1C1947"; // nano_33nefchqmo4ifr3bpfw4ecwjcg87semfhit8prwi7zzd8shjr8c9qdxeqmnx -char const * live_canary_public_key_data = "B614401AA37ACFC973ED36CE9E30E471D8971762A9557E6A00E9D7FFDA6EF410"; // nano_1z7ty8bc8xjxou6zmgp3pd8zesgr8thra17nqjfdbgjjr17tnj16fjntfqfn -std::string const test_canary_public_key_data = nano::get_env_or_default ("NANO_TEST_CANARY_PUB", "3BAD2C554ACE05F5E528FBBCE79D51E552C55FA765CCFD89B289C4835DE5F04A"); // nano_1gxf7jcnomi7yqkkjyxwwygo5sckrohtgsgezp6u74g6ifgydw4cajwbk8bf +char const * beta_canary_public_key_data = "B61453D27E843EB30B8288E37D5E7C64447F9202E589AB9E573DA4460DF7B21B"; // ban_3finchb9x33ype7r7495hoh9rs46hyb17sebogh7ghf6ar8zheiucm87mfha +char const * live_canary_public_key_data = "B61453D27E843EB30B8288E37D5E7C64447F9202E589AB9E573DA4460DF7B21B"; // ban_3finchb9x33ype7r7495hoh9rs46hyb17sebogh7ghf6ar8zheiucm87mfha +std::string const test_canary_public_key_data = nano::get_env_or_default ("NANO_TEST_CANARY_PUB", "B61453D27E843EB30B8288E37D5E7C64447F9202E589AB9E573DA4460DF7B21B"); // ban_3finchb9x33ype7r7495hoh9rs46hyb17sebogh7ghf6ar8zheiucm87mfha } -nano::network_params::network_params () : - network_params (network_constants::active_network) -{ -} +nano::keypair nano::dev::genesis_key{ dev_private_key_data }; +nano::network_params nano::dev::network_params{ nano::networks::nano_dev_network }; +nano::ledger_constants & nano::dev::constants{ nano::dev::network_params.ledger }; +std::shared_ptr & nano::dev::genesis = nano::dev::constants.genesis; -nano::network_params::network_params (nano::nano_networks network_a) : - network (network_a), ledger (network), voting (network), node (network), portmapping (network), bootstrap (network) +nano::network_params::network_params (nano::networks network_a) : + work{ network_a == nano::networks::nano_live_network ? nano::work_thresholds::publish_full : network_a == nano::networks::nano_beta_network ? nano::work_thresholds::publish_beta + : network_a == nano::networks::nano_test_network ? nano::work_thresholds::publish_test + : nano::work_thresholds::publish_dev }, + network{ work, network_a }, + ledger{ work, network_a }, + voting{ network }, + node{ network }, + portmapping{ network }, + bootstrap{ network } { unsigned constexpr kdf_full_work = 64 * 1024; unsigned constexpr kdf_dev_work = 8; kdf_work = network.is_dev_network () ? kdf_dev_work : kdf_full_work; - header_magic_number = network.is_dev_network () ? std::array{ { 'B', 'Z' } } : network.is_beta_network () ? std::array{ { 'B', 'Y' } } : network.is_live_network () ? std::array{ { 'B', 'X' } } : nano::test_magic_number (); -} - -uint8_t nano::protocol_constants::protocol_version_min () const -{ - return protocol_version_min_m; -} - -nano::ledger_constants::ledger_constants (nano::network_constants & network_constants) : - ledger_constants (network_constants.network ()) -{ } -nano::ledger_constants::ledger_constants (nano::nano_networks network_a) : +nano::ledger_constants::ledger_constants (nano::work_thresholds & work, nano::networks network_a) : + work{ work }, zero_key ("0"), - dev_genesis_key (dev_private_key_data), - nano_dev_account (dev_public_key_data), nano_beta_account (beta_public_key_data), nano_live_account (live_public_key_data), nano_test_account (test_public_key_data), - nano_dev_genesis (dev_genesis_data), - nano_beta_genesis (beta_genesis_data), - nano_live_genesis (live_genesis_data), - nano_test_genesis (test_genesis_data), - genesis_account (network_a == nano::nano_networks::nano_dev_network ? nano_dev_account : network_a == nano::nano_networks::nano_beta_network ? nano_beta_account : network_a == nano::nano_networks::nano_test_network ? nano_test_account : nano_live_account), - genesis_block (network_a == nano::nano_networks::nano_dev_network ? nano_dev_genesis : network_a == nano::nano_networks::nano_beta_network ? nano_beta_genesis : network_a == nano::nano_networks::nano_test_network ? nano_test_genesis : nano_live_genesis), - genesis_hash (parse_block_from_genesis_data (genesis_block)->hash ()), - genesis_amount (std::numeric_limits::max ()), - burn_account (0), + nano_dev_genesis (parse_block_from_genesis_data (dev_genesis_data)), + nano_beta_genesis (parse_block_from_genesis_data (beta_genesis_data)), + nano_live_genesis (parse_block_from_genesis_data (live_genesis_data)), + nano_test_genesis (parse_block_from_genesis_data (test_genesis_data)), + genesis (network_a == nano::networks::nano_dev_network ? nano_dev_genesis : network_a == nano::networks::nano_beta_network ? nano_beta_genesis + : network_a == nano::networks::nano_test_network ? nano_test_genesis + : nano_live_genesis), + genesis_amount{ std::numeric_limits::max () }, + burn_account{}, nano_dev_final_votes_canary_account (dev_public_key_data), nano_beta_final_votes_canary_account (beta_canary_public_key_data), nano_live_final_votes_canary_account (live_canary_public_key_data), nano_test_final_votes_canary_account (test_canary_public_key_data), - final_votes_canary_account (network_a == nano::nano_networks::nano_dev_network ? nano_dev_final_votes_canary_account : network_a == nano::nano_networks::nano_beta_network ? nano_beta_final_votes_canary_account : network_a == nano::nano_networks::nano_test_network ? nano_test_final_votes_canary_account : nano_live_final_votes_canary_account), + final_votes_canary_account (network_a == nano::networks::nano_dev_network ? nano_dev_final_votes_canary_account : network_a == nano::networks::nano_beta_network ? nano_beta_final_votes_canary_account + : network_a == nano::networks::nano_test_network ? nano_test_final_votes_canary_account + : nano_live_final_votes_canary_account), nano_dev_final_votes_canary_height (1), nano_beta_final_votes_canary_height (1), nano_live_final_votes_canary_height (1), nano_test_final_votes_canary_height (1), - final_votes_canary_height (network_a == nano::nano_networks::nano_dev_network ? nano_dev_final_votes_canary_height : network_a == nano::nano_networks::nano_beta_network ? nano_beta_final_votes_canary_height : network_a == nano::nano_networks::nano_test_network ? nano_test_final_votes_canary_height : nano_live_final_votes_canary_height) + final_votes_canary_height (network_a == nano::networks::nano_dev_network ? nano_dev_final_votes_canary_height : network_a == nano::networks::nano_beta_network ? nano_beta_final_votes_canary_height + : network_a == nano::networks::nano_test_network ? nano_test_final_votes_canary_height + : nano_live_final_votes_canary_height) { + nano_beta_genesis->sideband_set (nano::block_sideband (nano_beta_genesis->account (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + nano_dev_genesis->sideband_set (nano::block_sideband (nano_dev_genesis->account (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + nano_live_genesis->sideband_set (nano::block_sideband (nano_live_genesis->account (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + nano_test_genesis->sideband_set (nano::block_sideband (nano_test_genesis->account (), 0, std::numeric_limits::max (), 1, nano::seconds_since_epoch (), nano::epoch::epoch_0, false, false, false, nano::epoch::epoch_0)); + nano::link epoch_link_v1; - const char * epoch_message_v1 ("epoch v1 block"); + char const * epoch_message_v1 ("epoch v1 block"); strncpy ((char *)epoch_link_v1.bytes.data (), epoch_message_v1, epoch_link_v1.bytes.size ()); - epochs.add (nano::epoch::epoch_1, genesis_account, epoch_link_v1); + epochs.add (nano::epoch::epoch_1, genesis->account (), epoch_link_v1); nano::link epoch_link_v2; nano::account nano_live_epoch_v2_signer; auto error (nano_live_epoch_v2_signer.decode_account ("bano_3qb6o6i1tkzr6jwr5s7eehfxwg9x6eemitdinbpi7u8bjjwsgqfj4wzser3x")); debug_assert (!error); - auto epoch_v2_signer (network_a == nano::nano_networks::nano_dev_network ? nano_dev_account : network_a == nano::nano_networks::nano_beta_network ? nano_beta_account : network_a == nano::nano_networks::nano_test_network ? nano_test_account : nano_live_epoch_v2_signer); - const char * epoch_message_v2 ("epoch v2 block"); + auto epoch_v2_signer (network_a == nano::networks::nano_dev_network ? nano::dev::genesis_key.pub : network_a == nano::networks::nano_beta_network ? nano_beta_account + : network_a == nano::networks::nano_test_network ? nano_test_account + : nano_live_epoch_v2_signer); + char const * epoch_message_v2 ("epoch v2 block"); strncpy ((char *)epoch_link_v2.bytes.data (), epoch_message_v2, epoch_link_v2.bytes.size ()); epochs.add (nano::epoch::epoch_2, epoch_v2_signer, epoch_link_v2); } -nano::random_constants::random_constants () +nano::hardened_constants & nano::hardened_constants::get () +{ + static hardened_constants instance{}; + return instance; +} + +nano::hardened_constants::hardened_constants () : + not_an_account{}, + random_128{} { nano::random_pool::generate_block (not_an_account.bytes.data (), not_an_account.bytes.size ()); nano::random_pool::generate_block (random_128.bytes.data (), random_128.bytes.size ()); @@ -153,19 +169,10 @@ nano::random_constants::random_constants () nano::node_constants::node_constants (nano::network_constants & network_constants) { - period = network_constants.is_dev_network () ? std::chrono::seconds (1) : std::chrono::seconds (60); - half_period = network_constants.is_dev_network () ? std::chrono::milliseconds (500) : std::chrono::milliseconds (30 * 1000); - idle_timeout = network_constants.is_dev_network () ? period * 15 : period * 2; - cutoff = period * 5; - syn_cookie_cutoff = std::chrono::seconds (5); backup_interval = std::chrono::minutes (5); - bootstrap_interval = std::chrono::seconds (15 * 60); search_pending_interval = network_constants.is_dev_network () ? std::chrono::seconds (1) : std::chrono::seconds (5 * 60); - peer_interval = search_pending_interval; unchecked_cleaning_interval = std::chrono::minutes (30); process_confirmed_interval = network_constants.is_dev_network () ? std::chrono::milliseconds (50) : std::chrono::milliseconds (500); - max_peers_per_ip = network_constants.is_dev_network () ? 10 : 5; - max_peers_per_subnetwork = max_peers_per_ip * 4; max_weight_samples = (network_constants.is_live_network () || network_constants.is_test_network ()) ? 4032 : 288; weight_period = 5 * 60; // 5 minutes } @@ -266,13 +273,13 @@ bool nano::account_info::operator!= (nano::account_info const & other_a) const size_t nano::account_info::db_size () const { - debug_assert (reinterpret_cast (this) == reinterpret_cast (&head)); - debug_assert (reinterpret_cast (&head) + sizeof (head) == reinterpret_cast (&representative)); - debug_assert (reinterpret_cast (&representative) + sizeof (representative) == reinterpret_cast (&open_block)); - debug_assert (reinterpret_cast (&open_block) + sizeof (open_block) == reinterpret_cast (&balance)); - debug_assert (reinterpret_cast (&balance) + sizeof (balance) == reinterpret_cast (&modified)); - debug_assert (reinterpret_cast (&modified) + sizeof (modified) == reinterpret_cast (&block_count)); - debug_assert (reinterpret_cast (&block_count) + sizeof (block_count) == reinterpret_cast (&epoch_m)); + debug_assert (reinterpret_cast (this) == reinterpret_cast (&head)); + debug_assert (reinterpret_cast (&head) + sizeof (head) == reinterpret_cast (&representative)); + debug_assert (reinterpret_cast (&representative) + sizeof (representative) == reinterpret_cast (&open_block)); + debug_assert (reinterpret_cast (&open_block) + sizeof (open_block) == reinterpret_cast (&balance)); + debug_assert (reinterpret_cast (&balance) + sizeof (balance) == reinterpret_cast (&modified)); + debug_assert (reinterpret_cast (&modified) + sizeof (modified) == reinterpret_cast (&block_count)); + debug_assert (reinterpret_cast (&block_count) + sizeof (block_count) == reinterpret_cast (&epoch_m)); return sizeof (head) + sizeof (representative) + sizeof (open_block) + sizeof (balance) + sizeof (modified) + sizeof (block_count) + sizeof (epoch_m); } @@ -385,12 +392,12 @@ bool nano::unchecked_info::deserialize (nano::stream & stream_a) return error; } -nano::endpoint_key::endpoint_key (const std::array & address_a, uint16_t port_a) : +nano::endpoint_key::endpoint_key (std::array const & address_a, uint16_t port_a) : address (address_a), network_port (boost::endian::native_to_big (port_a)) { } -const std::array & nano::endpoint_key::address_bytes () const +std::array const & nano::endpoint_key::address_bytes () const { return address; } @@ -466,7 +473,7 @@ bool nano::vote::operator== (nano::vote const & other_a) const } } } - return timestamp == other_a.timestamp && blocks_equal && account == other_a.account && signature == other_a.signature; + return timestamp_m == other_a.timestamp_m && blocks_equal && account == other_a.account && signature == other_a.signature; } bool nano::vote::operator!= (nano::vote const & other_a) const @@ -478,8 +485,9 @@ void nano::vote::serialize_json (boost::property_tree::ptree & tree) const { tree.put ("account", account.to_account ()); tree.put ("signature", signature.number ()); - tree.put ("sequence", std::to_string (timestamp)); - tree.put ("timestamp", std::to_string (timestamp)); + tree.put ("sequence", std::to_string (timestamp ())); + tree.put ("timestamp", std::to_string (timestamp ())); + tree.put ("duration", std::to_string (duration_bits ())); boost::property_tree::ptree blocks_tree; for (auto block : blocks) { @@ -506,8 +514,28 @@ std::string nano::vote::to_json () const return stream.str (); } +uint64_t nano::vote::timestamp () const +{ + return timestamp_m; +} + +uint8_t nano::vote::duration_bits () const +{ + // Duration field is specified in the 4 low-order bits of the timestamp. + // This makes the timestamp have a minimum granularity of 16ms + // The duration is specified as 2^(duration + 4) giving it a range of 16-524,288ms in power of two increments + auto result = timestamp_m & ~timestamp_mask; + debug_assert (result < 16); + return static_cast (result); +} + +std::chrono::milliseconds nano::vote::duration () const +{ + return std::chrono::milliseconds{ 1u << (duration_bits () + 4) }; +} + nano::vote::vote (nano::vote const & other_a) : - timestamp{ other_a.timestamp }, + timestamp_m{ other_a.timestamp_m }, blocks (other_a.blocks), account (other_a.account), signature (other_a.signature) @@ -525,7 +553,7 @@ nano::vote::vote (bool & error_a, nano::stream & stream_a, nano::block_type type { nano::read (stream_a, account.bytes); nano::read (stream_a, signature.bytes); - nano::read (stream_a, timestamp); + nano::read (stream_a, timestamp_m); while (stream_a.in_avail () > 0) { @@ -557,16 +585,16 @@ nano::vote::vote (bool & error_a, nano::stream & stream_a, nano::block_type type } } -nano::vote::vote (nano::account const & account_a, nano::raw_key const & prv_a, uint64_t timestamp_a, std::shared_ptr const & block_a) : - timestamp{ timestamp_a }, +nano::vote::vote (nano::account const & account_a, nano::raw_key const & prv_a, uint64_t timestamp_a, uint8_t duration, std::shared_ptr const & block_a) : + timestamp_m{ packed_timestamp (timestamp_a, duration) }, blocks (1, block_a), account (account_a), signature (nano::sign_message (prv_a, account_a, hash ())) { } -nano::vote::vote (nano::account const & account_a, nano::raw_key const & prv_a, uint64_t timestamp_a, std::vector const & blocks_a) : - timestamp{ timestamp_a }, +nano::vote::vote (nano::account const & account_a, nano::raw_key const & prv_a, uint64_t timestamp_a, uint8_t duration, std::vector const & blocks_a) : + timestamp_m{ packed_timestamp (timestamp_a, duration) }, account (account_a) { debug_assert (!blocks_a.empty ()); @@ -587,7 +615,7 @@ std::string nano::vote::hashes_string () const return result; } -const std::string nano::vote::hash_prefix = "vote "; +std::string const nano::vote::hash_prefix = "vote "; nano::block_hash nano::vote::hash () const { @@ -607,7 +635,7 @@ nano::block_hash nano::vote::hash () const uint64_t qword; std::array bytes; }; - qword = timestamp; + qword = timestamp_m; blake2b_update (&hash, bytes.data (), sizeof (bytes)); blake2b_final (&hash, result.bytes.data (), sizeof (result.bytes)); return result; @@ -629,7 +657,7 @@ void nano::vote::serialize (nano::stream & stream_a, nano::block_type type) cons { write (stream_a, account); write (stream_a, signature); - write (stream_a, timestamp); + write (stream_a, boost::endian::native_to_little (timestamp_m)); for (auto const & block : blocks) { if (block.which ()) @@ -655,7 +683,7 @@ void nano::vote::serialize (nano::stream & stream_a) const { write (stream_a, account); write (stream_a, signature); - write (stream_a, timestamp); + write (stream_a, boost::endian::native_to_little (timestamp_m)); for (auto const & block : blocks) { if (block.which ()) @@ -677,7 +705,8 @@ bool nano::vote::deserialize (nano::stream & stream_a, nano::block_uniquer * uni { nano::read (stream_a, account); nano::read (stream_a, signature); - nano::read (stream_a, timestamp); + nano::read (stream_a, timestamp_m); + boost::endian::little_to_native_inplace (timestamp_m); nano::block_type type; @@ -725,6 +754,13 @@ bool nano::vote::validate () const return nano::validate_message (account, hash (), signature); } +uint64_t nano::vote::packed_timestamp (uint64_t timestamp, uint8_t duration) const +{ + debug_assert (duration <= duration_max && "Invalid duration"); + debug_assert ((!(timestamp == timestamp_max) || (duration == duration_max)) && "Invalid final vote"); + return (timestamp & timestamp_mask) | duration; +} + nano::block_hash nano::iterate_vote_blocks_as_hash::operator() (boost::variant, nano::block_hash> const & item) const { nano::block_hash result; @@ -816,18 +852,6 @@ std::unique_ptr nano::collect_container_info (vo return composite; } -nano::genesis::genesis () -{ - static nano::network_params network_params; - open = parse_block_from_genesis_data (network_params.ledger.genesis_block); - debug_assert (open != nullptr); -} - -nano::block_hash nano::genesis::hash () const -{ - return open->hash (); -} - nano::wallet_id nano::random_wallet_id () { nano::wallet_id wallet_id; diff --git a/nano/secure/common.hpp b/nano/secure/common.hpp index fb4af5200b..078ccdb774 100644 --- a/nano/secure/common.hpp +++ b/nano/secure/common.hpp @@ -99,7 +99,7 @@ class account_info final size_t db_size () const; nano::epoch epoch () const; nano::block_hash head{ 0 }; - nano::account representative{ 0 }; + nano::account representative{}; nano::block_hash open_block{ 0 }; nano::amount balance{ 0 }; /** Seconds since posix epoch */ @@ -119,7 +119,7 @@ class pending_info final size_t db_size () const; bool deserialize (nano::stream &); bool operator== (nano::pending_info const &) const; - nano::account source{ 0 }; + nano::account source{}; nano::amount amount{ 0 }; nano::epoch epoch{ nano::epoch::epoch_0 }; }; @@ -131,7 +131,7 @@ class pending_key final bool deserialize (nano::stream &); bool operator== (nano::pending_key const &) const; nano::account const & key () const; - nano::account account{ 0 }; + nano::account account{}; nano::block_hash hash{ 0 }; }; @@ -141,19 +141,19 @@ class endpoint_key final endpoint_key () = default; /* - * @param address_a This should be in network byte order - * @param port_a This should be in host byte order - */ - endpoint_key (const std::array & address_a, uint16_t port_a); + * @param address_a This should be in network byte order + * @param port_a This should be in host byte order + */ + endpoint_key (std::array const & address_a, uint16_t port_a); /* - * @return The ipv6 address in network byte order - */ - const std::array & address_bytes () const; + * @return The ipv6 address in network byte order + */ + std::array const & address_bytes () const; /* - * @return The port in host byte order - */ + * @return The port in host byte order + */ uint16_t port () const; private: @@ -202,7 +202,7 @@ class unchecked_info final void serialize (nano::stream &) const; bool deserialize (nano::stream &); std::shared_ptr block; - nano::account account{ 0 }; + nano::account account{}; /** Seconds since posix epoch */ uint64_t modified{ 0 }; nano::signature_verification verified{ nano::signature_verification::unknown }; @@ -214,7 +214,7 @@ class block_info final public: block_info () = default; block_info (nano::account const &, nano::amount const &); - nano::account account{ 0 }; + nano::account account{}; nano::amount balance{ 0 }; }; @@ -249,8 +249,8 @@ class vote final vote (nano::vote const &); vote (bool &, nano::stream &, nano::block_uniquer * = nullptr); vote (bool &, nano::stream &, nano::block_type, nano::block_uniquer * = nullptr); - vote (nano::account const &, nano::raw_key const &, uint64_t, std::shared_ptr const &); - vote (nano::account const &, nano::raw_key const &, uint64_t, std::vector const &); + vote (nano::account const &, nano::raw_key const &, uint64_t timestamp, uint8_t duration, std::shared_ptr const &); + vote (nano::account const &, nano::raw_key const &, uint64_t timestamp, uint8_t duration, std::vector const &); std::string hashes_string () const; nano::block_hash hash () const; nano::block_hash full_hash () const; @@ -264,15 +264,29 @@ class vote final boost::transform_iterator begin () const; boost::transform_iterator end () const; std::string to_json () const; + uint64_t timestamp () const; + uint8_t duration_bits () const; + std::chrono::milliseconds duration () const; + static uint64_t constexpr timestamp_mask = { 0xffff'ffff'ffff'fff0ULL }; + static uint64_t constexpr timestamp_max = { 0xffff'ffff'ffff'fff0ULL }; + static uint64_t constexpr timestamp_min = { 0x0000'0000'0000'0010ULL }; + static uint8_t constexpr duration_max = { 0x0fu }; + +private: // Vote timestamp - uint64_t timestamp; + uint64_t timestamp_m; + +public: // The blocks, or block hashes, that this vote is for std::vector, nano::block_hash>> blocks; // Account that's voting nano::account account; // Signature of timestamp + block hashes nano::signature signature; - static const std::string hash_prefix; + static std::string const hash_prefix; + +private: + uint64_t packed_timestamp (uint64_t timestamp, uint8_t duration) const; }; /** * This class serves to find and return unique variants of a vote in order to minimize memory usage @@ -280,7 +294,7 @@ class vote final class vote_uniquer final { public: - using value_type = std::pair>; + using value_type = std::pair>; vote_uniquer (nano::block_uniquer &); std::shared_ptr unique (std::shared_ptr const &); @@ -334,53 +348,23 @@ enum class tally_result confirm }; -class genesis final -{ -public: - genesis (); - nano::block_hash hash () const; - std::shared_ptr open; -}; - class network_params; -/** Protocol versions whose value may depend on the active network */ -class protocol_constants -{ -public: - /** Current protocol version */ - uint8_t const protocol_version = 0x12; - - /** Minimum accepted protocol version */ - uint8_t protocol_version_min () const; - -private: - /* Minimum protocol version we will establish connections to */ - uint8_t const protocol_version_min_m = 0x11; -}; - -// Some places use the decltype of protocol_version instead of protocol_version_min. To keep those checks simpler we check that the decltypes match ignoring differences in const -static_assert (std::is_same, decltype (protocol_constants ().protocol_version_min ())>::value, "protocol_min should match"); - /** Genesis keys and ledger constants for network variants */ class ledger_constants { public: - ledger_constants (nano::network_constants & network_constants); - ledger_constants (nano::nano_networks network_a); + ledger_constants (nano::work_thresholds & work, nano::networks network_a); + nano::work_thresholds & work; nano::keypair zero_key; - nano::keypair dev_genesis_key; - nano::account nano_dev_account; nano::account nano_beta_account; nano::account nano_live_account; nano::account nano_test_account; - std::string nano_dev_genesis; - std::string nano_beta_genesis; - std::string nano_live_genesis; - std::string nano_test_genesis; - nano::account genesis_account; - std::string genesis_block; - nano::block_hash genesis_hash; + std::shared_ptr nano_dev_genesis; + std::shared_ptr nano_beta_genesis; + std::shared_ptr nano_live_genesis; + std::shared_ptr nano_test_genesis; + std::shared_ptr genesis; nano::uint128_t genesis_amount; nano::account burn_account; nano::account nano_dev_final_votes_canary_account; @@ -396,13 +380,25 @@ class ledger_constants nano::epochs epochs; }; -/** Constants which depend on random values (this class should never be used globally due to CryptoPP globals potentially not being initialized) */ -class random_constants +namespace dev +{ + extern nano::keypair genesis_key; + extern nano::network_params network_params; + extern nano::ledger_constants & constants; + extern std::shared_ptr & genesis; +} + +/** Constants which depend on random values (always used as singleton) */ +class hardened_constants { public: - random_constants (); + static hardened_constants & get (); + nano::account not_an_account; nano::uint128_union random_128; + +private: + hardened_constants (); }; /** Node related constants whose value depends on the active network */ @@ -410,22 +406,10 @@ class node_constants { public: node_constants (nano::network_constants & network_constants); - std::chrono::seconds period; - std::chrono::milliseconds half_period; - /** Default maximum idle time for a socket before it's automatically closed */ - std::chrono::seconds idle_timeout; - std::chrono::seconds cutoff; - std::chrono::seconds syn_cookie_cutoff; std::chrono::minutes backup_interval; - std::chrono::seconds bootstrap_interval; std::chrono::seconds search_pending_interval; - std::chrono::seconds peer_interval; std::chrono::minutes unchecked_cleaning_interval; std::chrono::milliseconds process_confirmed_interval; - /** Maximum number of peers per IP */ - size_t max_peers_per_ip; - /** Maximum number of peers per subnetwork */ - size_t max_peers_per_subnetwork; /** The maximum amount of samples for a 2 week period on live or 1 day on beta */ uint64_t max_weight_samples; @@ -469,22 +453,17 @@ class bootstrap_constants class network_params { public: - /** Populate values based on the current active network */ - network_params (); - /** Populate values based on \p network_a */ - network_params (nano::nano_networks network_a); + network_params (nano::networks network_a); - std::array header_magic_number; unsigned kdf_work; - network_constants network; - protocol_constants protocol; - ledger_constants ledger; - random_constants random; - voting_constants voting; - node_constants node; - portmapping_constants portmapping; - bootstrap_constants bootstrap; + nano::work_thresholds work; + nano::network_constants network; + nano::ledger_constants ledger; + nano::voting_constants voting; + nano::node_constants node; + nano::portmapping_constants portmapping; + nano::bootstrap_constants bootstrap; }; enum class confirmation_height_mode @@ -495,7 +474,7 @@ enum class confirmation_height_mode }; /* Holds flags for various cacheable data. For most CLI operations caching is unnecessary - * (e.g getting the cemented block count) so it can be disabled for performance reasons. */ + * (e.g getting the cemented block count) so it can be disabled for performance reasons. */ class generate_cache { public: diff --git a/nano/secure/ledger.cpp b/nano/secure/ledger.cpp index a1ab9a0625..8d96206ccc 100644 --- a/nano/secure/ledger.cpp +++ b/nano/secure/ledger.cpp @@ -2,9 +2,9 @@ #include #include #include -#include #include #include +#include #include @@ -28,23 +28,23 @@ class rollback_visitor : public nano::block_visitor auto hash (block_a.hash ()); nano::pending_info pending; nano::pending_key key (block_a.hashables.destination, hash); - while (!error && ledger.store.pending_get (transaction, key, pending)) + while (!error && ledger.store.pending.get (transaction, key, pending)) { error = ledger.rollback (transaction, ledger.latest (transaction, block_a.hashables.destination), list); } if (!error) { nano::account_info info; - [[maybe_unused]] auto error (ledger.store.account_get (transaction, pending.source, info)); + [[maybe_unused]] auto error (ledger.store.account.get (transaction, pending.source, info)); debug_assert (!error); - ledger.store.pending_del (transaction, key); + ledger.store.pending.del (transaction, key); ledger.cache.rep_weights.representation_add (info.representative, pending.amount.number ()); nano::account_info new_info (block_a.hashables.previous, info.representative, info.open_block, ledger.balance (transaction, block_a.hashables.previous), nano::seconds_since_epoch (), info.block_count - 1, nano::epoch::epoch_0); ledger.update_account (transaction, pending.source, info, new_info); - ledger.store.block_del (transaction, hash); - ledger.store.frontier_del (transaction, hash); - ledger.store.frontier_put (transaction, block_a.hashables.previous, pending.source); - ledger.store.block_successor_clear (transaction, block_a.hashables.previous); + ledger.store.block.del (transaction, hash); + ledger.store.frontier.del (transaction, hash); + ledger.store.frontier.put (transaction, block_a.hashables.previous, pending.source); + ledger.store.block.successor_clear (transaction, block_a.hashables.previous); ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::send); } } @@ -57,16 +57,16 @@ class rollback_visitor : public nano::block_visitor [[maybe_unused]] bool is_pruned (false); auto source_account (ledger.account_safe (transaction, block_a.hashables.source, is_pruned)); nano::account_info info; - [[maybe_unused]] auto error (ledger.store.account_get (transaction, destination_account, info)); + [[maybe_unused]] auto error (ledger.store.account.get (transaction, destination_account, info)); debug_assert (!error); ledger.cache.rep_weights.representation_add (info.representative, 0 - amount); nano::account_info new_info (block_a.hashables.previous, info.representative, info.open_block, ledger.balance (transaction, block_a.hashables.previous), nano::seconds_since_epoch (), info.block_count - 1, nano::epoch::epoch_0); ledger.update_account (transaction, destination_account, info, new_info); - ledger.store.block_del (transaction, hash); - ledger.store.pending_put (transaction, nano::pending_key (destination_account, block_a.hashables.source), { source_account, amount, nano::epoch::epoch_0 }); - ledger.store.frontier_del (transaction, hash); - ledger.store.frontier_put (transaction, block_a.hashables.previous, destination_account); - ledger.store.block_successor_clear (transaction, block_a.hashables.previous); + ledger.store.block.del (transaction, hash); + ledger.store.pending.put (transaction, nano::pending_key (destination_account, block_a.hashables.source), { source_account, amount, nano::epoch::epoch_0 }); + ledger.store.frontier.del (transaction, hash); + ledger.store.frontier.put (transaction, block_a.hashables.previous, destination_account); + ledger.store.block.successor_clear (transaction, block_a.hashables.previous); ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::receive); } void open_block (nano::open_block const & block_a) override @@ -80,9 +80,9 @@ class rollback_visitor : public nano::block_visitor ledger.cache.rep_weights.representation_add (block_a.representative (), 0 - amount); nano::account_info new_info; ledger.update_account (transaction, destination_account, new_info, new_info); - ledger.store.block_del (transaction, hash); - ledger.store.pending_put (transaction, nano::pending_key (destination_account, block_a.hashables.source), { source_account, amount, nano::epoch::epoch_0 }); - ledger.store.frontier_del (transaction, hash); + ledger.store.block.del (transaction, hash); + ledger.store.pending.put (transaction, nano::pending_key (destination_account, block_a.hashables.source), { source_account, amount, nano::epoch::epoch_0 }); + ledger.store.frontier.del (transaction, hash); ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::open); } void change_block (nano::change_block const & block_a) override @@ -91,19 +91,19 @@ class rollback_visitor : public nano::block_visitor auto rep_block (ledger.representative (transaction, block_a.hashables.previous)); auto account (ledger.account (transaction, block_a.hashables.previous)); nano::account_info info; - [[maybe_unused]] auto error (ledger.store.account_get (transaction, account, info)); + [[maybe_unused]] auto error (ledger.store.account.get (transaction, account, info)); debug_assert (!error); auto balance (ledger.balance (transaction, block_a.hashables.previous)); - auto block = ledger.store.block_get (transaction, rep_block); + auto block = ledger.store.block.get (transaction, rep_block); release_assert (block != nullptr); auto representative = block->representative (); ledger.cache.rep_weights.representation_add_dual (block_a.representative (), 0 - balance, representative, balance); - ledger.store.block_del (transaction, hash); + ledger.store.block.del (transaction, hash); nano::account_info new_info (block_a.hashables.previous, representative, info.open_block, info.balance, nano::seconds_since_epoch (), info.block_count - 1, nano::epoch::epoch_0); ledger.update_account (transaction, account, info, new_info); - ledger.store.frontier_del (transaction, hash); - ledger.store.frontier_put (transaction, block_a.hashables.previous, account); - ledger.store.block_successor_clear (transaction, block_a.hashables.previous); + ledger.store.frontier.del (transaction, hash); + ledger.store.frontier.put (transaction, block_a.hashables.previous, account); + ledger.store.block.successor_clear (transaction, block_a.hashables.previous); ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::change); } void state_block (nano::state_block const & block_a) override @@ -116,11 +116,11 @@ class rollback_visitor : public nano::block_visitor } auto balance (ledger.balance (transaction, block_a.hashables.previous)); auto is_send (block_a.hashables.balance < balance); - nano::account representative{ 0 }; + nano::account representative{}; if (!rep_block_hash.is_zero ()) { // Move existing representation & add in amount delta - auto block (ledger.store.block_get (transaction, rep_block_hash)); + auto block (ledger.store.block.get (transaction, rep_block_hash)); debug_assert (block != nullptr); representative = block->representative (); ledger.cache.rep_weights.representation_add_dual (representative, balance, block_a.representative (), 0 - block_a.hashables.balance.number ()); @@ -132,16 +132,16 @@ class rollback_visitor : public nano::block_visitor } nano::account_info info; - auto error (ledger.store.account_get (transaction, block_a.hashables.account, info)); + auto error (ledger.store.account.get (transaction, block_a.hashables.account, info)); if (is_send) { nano::pending_key key (block_a.hashables.link.as_account (), hash); - while (!error && !ledger.store.pending_exists (transaction, key)) + while (!error && !ledger.store.pending.exists (transaction, key)) { error = ledger.rollback (transaction, ledger.latest (transaction, block_a.hashables.link.as_account ()), list); } - ledger.store.pending_del (transaction, key); + ledger.store.pending.del (transaction, key); ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::send); } else if (!block_a.hashables.link.is_zero () && !ledger.is_epoch_link (block_a.hashables.link)) @@ -150,29 +150,29 @@ class rollback_visitor : public nano::block_visitor [[maybe_unused]] bool is_pruned (false); auto source_account (ledger.account_safe (transaction, block_a.hashables.link.as_block_hash (), is_pruned)); nano::pending_info pending_info (source_account, block_a.hashables.balance.number () - balance, block_a.sideband ().source_epoch); - ledger.store.pending_put (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link.as_block_hash ()), pending_info); + ledger.store.pending.put (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link.as_block_hash ()), pending_info); ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::receive); } debug_assert (!error); - auto previous_version (ledger.store.block_version (transaction, block_a.hashables.previous)); + auto previous_version (ledger.store.block.version (transaction, block_a.hashables.previous)); nano::account_info new_info (block_a.hashables.previous, representative, info.open_block, balance, nano::seconds_since_epoch (), info.block_count - 1, previous_version); ledger.update_account (transaction, block_a.hashables.account, info, new_info); - auto previous (ledger.store.block_get (transaction, block_a.hashables.previous)); + auto previous (ledger.store.block.get (transaction, block_a.hashables.previous)); if (previous != nullptr) { - ledger.store.block_successor_clear (transaction, block_a.hashables.previous); + ledger.store.block.successor_clear (transaction, block_a.hashables.previous); if (previous->type () < nano::block_type::state) { - ledger.store.frontier_put (transaction, block_a.hashables.previous, block_a.hashables.account); + ledger.store.frontier.put (transaction, block_a.hashables.previous, block_a.hashables.account); } } else { ledger.stats.inc (nano::stat::type::rollback, nano::stat::detail::open); } - ledger.store.block_del (transaction, hash); + ledger.store.block.del (transaction, hash); } nano::write_transaction const & transaction; nano::ledger & ledger; @@ -208,7 +208,7 @@ bool ledger_processor::validate_epoch_block (nano::state_block const & block_a) nano::amount prev_balance (0); if (!block_a.hashables.previous.is_zero ()) { - result.code = ledger.store.block_exists (transaction, block_a.hashables.previous) ? nano::process_result::progress : nano::process_result::gap_previous; + result.code = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::process_result::progress : nano::process_result::gap_previous; if (result.code == nano::process_result::progress) { prev_balance = ledger.balance (transaction, block_a.hashables.previous); @@ -286,7 +286,7 @@ void ledger_processor::state_block_impl (nano::state_block & block_a) nano::amount amount (block_a.hashables.balance); auto is_send (false); auto is_receive (false); - auto account_error (ledger.store.account_get (transaction, block_a.hashables.account, info)); + auto account_error (ledger.store.account.get (transaction, block_a.hashables.account, info)); if (!account_error) { // Account already exists @@ -295,7 +295,7 @@ void ledger_processor::state_block_impl (nano::state_block & block_a) result.code = block_a.hashables.previous.is_zero () ? nano::process_result::fork : nano::process_result::progress; // Has this account already been opened? (Ambigious) if (result.code == nano::process_result::progress) { - result.code = ledger.store.block_exists (transaction, block_a.hashables.previous) ? nano::process_result::progress : nano::process_result::gap_previous; // Does the previous block exist in the ledger? (Unambigious) + result.code = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::process_result::progress : nano::process_result::gap_previous; // Does the previous block exist in the ledger? (Unambigious) if (result.code == nano::process_result::progress) { is_send = block_a.hashables.balance < info.balance; @@ -327,7 +327,7 @@ void ledger_processor::state_block_impl (nano::state_block & block_a) { nano::pending_key key (block_a.hashables.account, block_a.hashables.link.as_block_hash ()); nano::pending_info pending; - result.code = ledger.store.pending_get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed) + result.code = ledger.store.pending.get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed) if (result.code == nano::process_result::progress) { result.code = amount == pending.amount ? nano::process_result::progress : nano::process_result::balance_mismatch; @@ -346,12 +346,12 @@ void ledger_processor::state_block_impl (nano::state_block & block_a) if (result.code == nano::process_result::progress) { nano::block_details block_details (epoch, is_send, is_receive, false); - result.code = block_a.difficulty () >= nano::work_threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) + result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) if (result.code == nano::process_result::progress) { ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::state_block); block_a.sideband_set (nano::block_sideband (block_a.hashables.account /* unused */, 0, 0 /* unused */, info.block_count + 1, nano::seconds_since_epoch (), block_details, source_epoch)); - ledger.store.block_put (transaction, hash, block_a); + ledger.store.block.put (transaction, hash, block_a); if (!info.head.is_zero ()) { @@ -368,18 +368,18 @@ void ledger_processor::state_block_impl (nano::state_block & block_a) { nano::pending_key key (block_a.hashables.link.as_account (), hash); nano::pending_info info (block_a.hashables.account, amount.number (), epoch); - ledger.store.pending_put (transaction, key, info); + ledger.store.pending.put (transaction, key, info); } else if (!block_a.hashables.link.is_zero ()) { - ledger.store.pending_del (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link.as_block_hash ())); + ledger.store.pending.del (transaction, nano::pending_key (block_a.hashables.account, block_a.hashables.link.as_block_hash ())); } nano::account_info new_info (hash, block_a.representative (), info.open_block.is_zero () ? hash : info.open_block, block_a.hashables.balance, nano::seconds_since_epoch (), info.block_count + 1, epoch); ledger.update_account (transaction, block_a.hashables.account, info, new_info); - if (!ledger.store.frontier_get (transaction, info.head).is_zero ()) + if (!ledger.store.frontier.get (transaction, info.head).is_zero ()) { - ledger.store.frontier_del (transaction, info.head); + ledger.store.frontier.del (transaction, info.head); } } } @@ -408,7 +408,7 @@ void ledger_processor::epoch_block_impl (nano::state_block & block_a) if (result.code == nano::process_result::progress) { nano::account_info info; - auto account_error (ledger.store.account_get (transaction, block_a.hashables.account, info)); + auto account_error (ledger.store.account.get (transaction, block_a.hashables.account, info)); if (!account_error) { // Account already exists @@ -430,13 +430,13 @@ void ledger_processor::epoch_block_impl (nano::state_block & block_a) // Non-exisitng account should have pending entries if (result.code == nano::process_result::progress) { - bool pending_exists = ledger.store.pending_any (transaction, block_a.hashables.account); + bool pending_exists = ledger.store.pending.any (transaction, block_a.hashables.account); result.code = pending_exists ? nano::process_result::progress : nano::process_result::gap_epoch_open_pending; } } if (result.code == nano::process_result::progress) { - auto epoch = ledger.network_params.ledger.epochs.epoch (block_a.hashables.link); + auto epoch = ledger.constants.epochs.epoch (block_a.hashables.link); // Must be an epoch for an unopened account or the epoch upgrade must be sequential auto is_valid_epoch_upgrade = account_error ? static_cast> (epoch) > 0 : nano::epochs::is_sequential (info.epoch (), epoch); result.code = is_valid_epoch_upgrade ? nano::process_result::progress : nano::process_result::block_position; @@ -446,17 +446,17 @@ void ledger_processor::epoch_block_impl (nano::state_block & block_a) if (result.code == nano::process_result::progress) { nano::block_details block_details (epoch, false, false, true); - result.code = block_a.difficulty () >= nano::work_threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) + result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) if (result.code == nano::process_result::progress) { ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::epoch_block); block_a.sideband_set (nano::block_sideband (block_a.hashables.account /* unused */, 0, 0 /* unused */, info.block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */)); - ledger.store.block_put (transaction, hash, block_a); + ledger.store.block.put (transaction, hash, block_a); nano::account_info new_info (hash, block_a.representative (), info.open_block.is_zero () ? hash : info.open_block, info.balance, nano::seconds_since_epoch (), info.block_count + 1, epoch); ledger.update_account (transaction, block_a.hashables.account, info, new_info); - if (!ledger.store.frontier_get (transaction, info.head).is_zero ()) + if (!ledger.store.frontier.get (transaction, info.head).is_zero ()) { - ledger.store.frontier_del (transaction, info.head); + ledger.store.frontier.del (transaction, info.head); } } } @@ -474,19 +474,19 @@ void ledger_processor::change_block (nano::change_block & block_a) result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Harmless) if (result.code == nano::process_result::progress) { - auto previous (ledger.store.block_get (transaction, block_a.hashables.previous)); + auto previous (ledger.store.block.get (transaction, block_a.hashables.previous)); result.code = previous != nullptr ? nano::process_result::progress : nano::process_result::gap_previous; // Have we seen the previous block already? (Harmless) if (result.code == nano::process_result::progress) { result.code = block_a.valid_predecessor (*previous) ? nano::process_result::progress : nano::process_result::block_position; if (result.code == nano::process_result::progress) { - auto account (ledger.store.frontier_get (transaction, block_a.hashables.previous)); + auto account (ledger.store.frontier.get (transaction, block_a.hashables.previous)); result.code = account.is_zero () ? nano::process_result::fork : nano::process_result::progress; if (result.code == nano::process_result::progress) { nano::account_info info; - auto latest_error (ledger.store.account_get (transaction, account, info)); + auto latest_error (ledger.store.account.get (transaction, account, info)); (void)latest_error; debug_assert (!latest_error); debug_assert (info.head == block_a.hashables.previous); @@ -498,19 +498,19 @@ void ledger_processor::change_block (nano::change_block & block_a) if (result.code == nano::process_result::progress) { nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */); - result.code = block_a.difficulty () >= nano::work_threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) + result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) if (result.code == nano::process_result::progress) { debug_assert (!validate_message (account, hash, block_a.signature)); result.verified = nano::signature_verification::valid; block_a.sideband_set (nano::block_sideband (account, 0, info.balance, info.block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */)); - ledger.store.block_put (transaction, hash, block_a); + ledger.store.block.put (transaction, hash, block_a); auto balance (ledger.balance (transaction, block_a.hashables.previous)); ledger.cache.rep_weights.representation_add_dual (block_a.representative (), balance, info.representative, 0 - balance); nano::account_info new_info (hash, block_a.representative (), info.open_block, info.balance, nano::seconds_since_epoch (), info.block_count + 1, nano::epoch::epoch_0); ledger.update_account (transaction, account, info, new_info); - ledger.store.frontier_del (transaction, block_a.hashables.previous); - ledger.store.frontier_put (transaction, hash, account); + ledger.store.frontier.del (transaction, block_a.hashables.previous); + ledger.store.frontier.put (transaction, hash, account); result.previous_balance = info.balance; ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::change); } @@ -528,14 +528,14 @@ void ledger_processor::send_block (nano::send_block & block_a) result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block before? (Harmless) if (result.code == nano::process_result::progress) { - auto previous (ledger.store.block_get (transaction, block_a.hashables.previous)); + auto previous (ledger.store.block.get (transaction, block_a.hashables.previous)); result.code = previous != nullptr ? nano::process_result::progress : nano::process_result::gap_previous; // Have we seen the previous block already? (Harmless) if (result.code == nano::process_result::progress) { result.code = block_a.valid_predecessor (*previous) ? nano::process_result::progress : nano::process_result::block_position; if (result.code == nano::process_result::progress) { - auto account (ledger.store.frontier_get (transaction, block_a.hashables.previous)); + auto account (ledger.store.frontier.get (transaction, block_a.hashables.previous)); result.code = account.is_zero () ? nano::process_result::fork : nano::process_result::progress; if (result.code == nano::process_result::progress) { @@ -547,13 +547,13 @@ void ledger_processor::send_block (nano::send_block & block_a) if (result.code == nano::process_result::progress) { nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */); - result.code = block_a.difficulty () >= nano::work_threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) + result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) if (result.code == nano::process_result::progress) { debug_assert (!validate_message (account, hash, block_a.signature)); result.verified = nano::signature_verification::valid; nano::account_info info; - auto latest_error (ledger.store.account_get (transaction, account, info)); + auto latest_error (ledger.store.account.get (transaction, account, info)); (void)latest_error; debug_assert (!latest_error); debug_assert (info.head == block_a.hashables.previous); @@ -563,12 +563,12 @@ void ledger_processor::send_block (nano::send_block & block_a) auto amount (info.balance.number () - block_a.hashables.balance.number ()); ledger.cache.rep_weights.representation_add (info.representative, 0 - amount); block_a.sideband_set (nano::block_sideband (account, 0, block_a.hashables.balance /* unused */, info.block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */)); - ledger.store.block_put (transaction, hash, block_a); + ledger.store.block.put (transaction, hash, block_a); nano::account_info new_info (hash, info.representative, info.open_block, block_a.hashables.balance, nano::seconds_since_epoch (), info.block_count + 1, nano::epoch::epoch_0); ledger.update_account (transaction, account, info, new_info); - ledger.store.pending_put (transaction, nano::pending_key (block_a.hashables.destination, hash), { account, amount, nano::epoch::epoch_0 }); - ledger.store.frontier_del (transaction, block_a.hashables.previous); - ledger.store.frontier_put (transaction, hash, account); + ledger.store.pending.put (transaction, nano::pending_key (block_a.hashables.destination, hash), { account, amount, nano::epoch::epoch_0 }); + ledger.store.frontier.del (transaction, block_a.hashables.previous); + ledger.store.frontier.put (transaction, hash, account); result.previous_balance = info.balance; ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::send); } @@ -587,14 +587,14 @@ void ledger_processor::receive_block (nano::receive_block & block_a) result.code = existing ? nano::process_result::old : nano::process_result::progress; // Have we seen this block already? (Harmless) if (result.code == nano::process_result::progress) { - auto previous (ledger.store.block_get (transaction, block_a.hashables.previous)); + auto previous (ledger.store.block.get (transaction, block_a.hashables.previous)); result.code = previous != nullptr ? nano::process_result::progress : nano::process_result::gap_previous; if (result.code == nano::process_result::progress) { result.code = block_a.valid_predecessor (*previous) ? nano::process_result::progress : nano::process_result::block_position; if (result.code == nano::process_result::progress) { - auto account (ledger.store.frontier_get (transaction, block_a.hashables.previous)); + auto account (ledger.store.frontier.get (transaction, block_a.hashables.previous)); result.code = account.is_zero () ? nano::process_result::gap_previous : nano::process_result::progress; //Have we seen the previous block? No entries for account at all (Harmless) if (result.code == nano::process_result::progress) { @@ -611,39 +611,39 @@ void ledger_processor::receive_block (nano::receive_block & block_a) if (result.code == nano::process_result::progress) { nano::account_info info; - ledger.store.account_get (transaction, account, info); + ledger.store.account.get (transaction, account, info); result.code = info.head == block_a.hashables.previous ? nano::process_result::progress : nano::process_result::gap_previous; // Block doesn't immediately follow latest block (Harmless) if (result.code == nano::process_result::progress) { nano::pending_key key (account, block_a.hashables.source); nano::pending_info pending; - result.code = ledger.store.pending_get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed) + result.code = ledger.store.pending.get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed) if (result.code == nano::process_result::progress) { result.code = pending.epoch == nano::epoch::epoch_0 ? nano::process_result::progress : nano::process_result::unreceivable; // Are we receiving a state-only send? (Malformed) if (result.code == nano::process_result::progress) { nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */); - result.code = block_a.difficulty () >= nano::work_threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) + result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) if (result.code == nano::process_result::progress) { auto new_balance (info.balance.number () + pending.amount.number ()); #ifdef NDEBUG - if (ledger.store.block_exists (transaction, block_a.hashables.source)) + if (ledger.store.block.exists (transaction, block_a.hashables.source)) { nano::account_info source_info; - [[maybe_unused]] auto error (ledger.store.account_get (transaction, pending.source, source_info)); + [[maybe_unused]] auto error (ledger.store.account.get (transaction, pending.source, source_info)); debug_assert (!error); } #endif - ledger.store.pending_del (transaction, key); + ledger.store.pending.del (transaction, key); block_a.sideband_set (nano::block_sideband (account, 0, new_balance, info.block_count + 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */)); - ledger.store.block_put (transaction, hash, block_a); + ledger.store.block.put (transaction, hash, block_a); nano::account_info new_info (hash, info.representative, info.open_block, new_balance, nano::seconds_since_epoch (), info.block_count + 1, nano::epoch::epoch_0); ledger.update_account (transaction, account, info, new_info); ledger.cache.rep_weights.representation_add (info.representative, pending.amount.number ()); - ledger.store.frontier_del (transaction, block_a.hashables.previous); - ledger.store.frontier_put (transaction, hash, account); + ledger.store.frontier.del (transaction, block_a.hashables.previous); + ledger.store.frontier.put (transaction, hash, account); result.previous_balance = info.balance; ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::receive); } @@ -655,7 +655,7 @@ void ledger_processor::receive_block (nano::receive_block & block_a) } else { - result.code = ledger.store.block_exists (transaction, block_a.hashables.previous) ? nano::process_result::fork : nano::process_result::gap_previous; // If we have the block but it's not the latest we have a signed fork (Malicious) + result.code = ledger.store.block.exists (transaction, block_a.hashables.previous) ? nano::process_result::fork : nano::process_result::gap_previous; // If we have the block but it's not the latest we have a signed fork (Malicious) } } } @@ -682,39 +682,39 @@ void ledger_processor::open_block (nano::open_block & block_a) if (result.code == nano::process_result::progress) { nano::account_info info; - result.code = ledger.store.account_get (transaction, block_a.hashables.account, info) ? nano::process_result::progress : nano::process_result::fork; // Has this account already been opened? (Malicious) + result.code = ledger.store.account.get (transaction, block_a.hashables.account, info) ? nano::process_result::progress : nano::process_result::fork; // Has this account already been opened? (Malicious) if (result.code == nano::process_result::progress) { nano::pending_key key (block_a.hashables.account, block_a.hashables.source); nano::pending_info pending; - result.code = ledger.store.pending_get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed) + result.code = ledger.store.pending.get (transaction, key, pending) ? nano::process_result::unreceivable : nano::process_result::progress; // Has this source already been received (Malformed) if (result.code == nano::process_result::progress) { - result.code = block_a.hashables.account == ledger.network_params.ledger.burn_account ? nano::process_result::opened_burn_account : nano::process_result::progress; // Is it burning 0 account? (Malicious) + result.code = block_a.hashables.account == ledger.constants.burn_account ? nano::process_result::opened_burn_account : nano::process_result::progress; // Is it burning 0 account? (Malicious) if (result.code == nano::process_result::progress) { result.code = pending.epoch == nano::epoch::epoch_0 ? nano::process_result::progress : nano::process_result::unreceivable; // Are we receiving a state-only send? (Malformed) if (result.code == nano::process_result::progress) { nano::block_details block_details (nano::epoch::epoch_0, false /* unused */, false /* unused */, false /* unused */); - result.code = block_a.difficulty () >= nano::work_threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) + result.code = ledger.constants.work.difficulty (block_a) >= ledger.constants.work.threshold (block_a.work_version (), block_details) ? nano::process_result::progress : nano::process_result::insufficient_work; // Does this block have sufficient work? (Malformed) if (result.code == nano::process_result::progress) { #ifdef NDEBUG - if (ledger.store.block_exists (transaction, block_a.hashables.source)) + if (ledger.store.block.exists (transaction, block_a.hashables.source)) { nano::account_info source_info; - [[maybe_unused]] auto error (ledger.store.account_get (transaction, pending.source, source_info)); + [[maybe_unused]] auto error (ledger.store.account.get (transaction, pending.source, source_info)); debug_assert (!error); } #endif - ledger.store.pending_del (transaction, key); + ledger.store.pending.del (transaction, key); block_a.sideband_set (nano::block_sideband (block_a.hashables.account, 0, pending.amount, 1, nano::seconds_since_epoch (), block_details, nano::epoch::epoch_0 /* unused */)); - ledger.store.block_put (transaction, hash, block_a); + ledger.store.block.put (transaction, hash, block_a); nano::account_info new_info (hash, block_a.representative (), hash, pending.amount.number (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0); ledger.update_account (transaction, block_a.hashables.account, info, new_info); ledger.cache.rep_weights.representation_add (block_a.representative (), pending.amount.number ()); - ledger.store.frontier_put (transaction, hash, block_a.hashables.account); + ledger.store.frontier.put (transaction, hash, block_a.hashables.account); result.previous_balance = 0; ledger.stats.inc (nano::stat::type::ledger, nano::stat::detail::open); } @@ -736,10 +736,11 @@ ledger_processor::ledger_processor (nano::ledger & ledger_a, nano::write_transac } } // namespace -nano::ledger::ledger (nano::block_store & store_a, nano::stat & stat_a, nano::generate_cache const & generate_cache_a) : - store (store_a), - stats (stat_a), - check_bootstrap_weights (true) +nano::ledger::ledger (nano::store & store_a, nano::stat & stat_a, nano::ledger_constants & constants, nano::generate_cache const & generate_cache_a) : + constants{ constants }, + store{ store_a }, + stats{ stat_a }, + check_bootstrap_weights{ true } { if (!store.init_error ()) { @@ -751,7 +752,7 @@ void nano::ledger::initialize (nano::generate_cache const & generate_cache_a) { if (generate_cache_a.reps || generate_cache_a.account_count || generate_cache_a.block_count) { - store.accounts_for_each_par ( + store.account.for_each_par ( [this] (nano::read_transaction const & /*unused*/, nano::store_iterator i, nano::store_iterator n) { uint64_t block_count_l{ 0 }; uint64_t account_count_l{ 0 }; @@ -771,7 +772,7 @@ void nano::ledger::initialize (nano::generate_cache const & generate_cache_a) if (generate_cache_a.cemented_count) { - store.confirmation_height_for_each_par ( + store.confirmation_height.for_each_par ( [this] (nano::read_transaction const & /*unused*/, nano::store_iterator i, nano::store_iterator n) { uint64_t cemented_count_l (0); for (; i != n; ++i) @@ -783,26 +784,26 @@ void nano::ledger::initialize (nano::generate_cache const & generate_cache_a) } auto transaction (store.tx_begin_read ()); - cache.pruned_count = store.pruned_count (transaction); + cache.pruned_count = store.pruned.count (transaction); // Final votes requirement for confirmation canary block nano::confirmation_height_info confirmation_height_info; - if (!store.confirmation_height_get (transaction, network_params.ledger.final_votes_canary_account, confirmation_height_info)) + if (!store.confirmation_height.get (transaction, constants.final_votes_canary_account, confirmation_height_info)) { - cache.final_votes_confirmation_canary = (confirmation_height_info.height >= network_params.ledger.final_votes_canary_height); + cache.final_votes_confirmation_canary = (confirmation_height_info.height >= constants.final_votes_canary_height); } } // Balance for account containing hash nano::uint128_t nano::ledger::balance (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const { - return hash_a.is_zero () ? 0 : store.block_balance (transaction_a, hash_a); + return hash_a.is_zero () ? 0 : store.block.balance (transaction_a, hash_a); } nano::uint128_t nano::ledger::balance_safe (nano::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const { nano::uint128_t result (0); - if (pruning && !hash_a.is_zero () && !store.block_exists (transaction_a, hash_a)) + if (pruning && !hash_a.is_zero () && !store.block.exists (transaction_a, hash_a)) { error_a = true; result = 0; @@ -821,7 +822,7 @@ nano::uint128_t nano::ledger::account_balance (nano::transaction const & transac if (only_confirmed_a) { nano::confirmation_height_info info; - if (!store.confirmation_height_get (transaction_a, account_a, info)) + if (!store.confirmation_height.get (transaction_a, account_a, info)) { result = balance (transaction_a, info.frontier); } @@ -829,7 +830,7 @@ nano::uint128_t nano::ledger::account_balance (nano::transaction const & transac else { nano::account_info info; - auto none (store.account_get (transaction_a, account_a, info)); + auto none (store.account.get (transaction_a, account_a, info)); if (!none) { result = info.balance.number (); @@ -842,7 +843,7 @@ nano::uint128_t nano::ledger::account_pending (nano::transaction const & transac { nano::uint128_t result (0); nano::account end (account_a.number () + 1); - for (auto i (store.pending_begin (transaction_a, nano::pending_key (account_a, 0))), n (store.pending_begin (transaction_a, nano::pending_key (end, 0))); i != n; ++i) + for (auto i (store.pending.begin (transaction_a, nano::pending_key (account_a, 0))), n (store.pending.begin (transaction_a, nano::pending_key (end, 0))); i != n; ++i) { nano::pending_info const & info (i->second); if (only_confirmed_a) @@ -862,7 +863,7 @@ nano::uint128_t nano::ledger::account_pending (nano::transaction const & transac nano::process_return nano::ledger::process (nano::write_transaction const & transaction_a, nano::block & block_a, nano::signature_verification verification) { - debug_assert (!nano::work_validate_entry (block_a) || network_params.network.is_dev_network ()); + debug_assert (!constants.work.validate_entry (block_a) || constants.genesis == nano::dev::genesis); ledger_processor processor (*this, transaction_a, verification); block_a.visit (processor); if (processor.result.code == nano::process_result::progress) @@ -875,7 +876,7 @@ nano::process_return nano::ledger::process (nano::write_transaction const & tran nano::block_hash nano::ledger::representative (nano::transaction const & transaction_a, nano::block_hash const & hash_a) { auto result (representative_calculated (transaction_a, hash_a)); - debug_assert (result.is_zero () || store.block_exists (transaction_a, result)); + debug_assert (result.is_zero () || store.block.exists (transaction_a, result)); return result; } @@ -893,11 +894,11 @@ bool nano::ledger::block_or_pruned_exists (nano::block_hash const & hash_a) cons bool nano::ledger::block_or_pruned_exists (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const { - if (store.pruned_exists (transaction_a, hash_a)) + if (store.pruned.exists (transaction_a, hash_a)) { return true; } - return store.block_exists (transaction_a, hash_a); + return store.block.exists (transaction_a, hash_a); } std::string nano::ledger::block_text (char const * hash_a) @@ -909,7 +910,7 @@ std::string nano::ledger::block_text (nano::block_hash const & hash_a) { std::string result; auto transaction (store.tx_begin_read ()); - auto block (store.block_get (transaction, hash_a)); + auto block (store.block.get (transaction, hash_a)); if (block != nullptr) { block->serialize_json (result); @@ -924,7 +925,7 @@ bool nano::ledger::is_send (nano::transaction const & transaction_a, nano::state * requires that the previous block exists in the database. * This is because it must retrieve the balance of the previous block. */ - debug_assert (block_a.has_sideband () || block_a.hashables.previous.is_zero () || store.block_exists (transaction_a, block_a.hashables.previous)); + debug_assert (block_a.has_sideband () || block_a.hashables.previous.is_zero () || store.block.exists (transaction_a, block_a.hashables.previous)); bool result (false); if (block_a.has_sideband ()) @@ -957,8 +958,8 @@ nano::account const & nano::ledger::block_destination (nano::transaction const & { return state_block->hashables.link.as_account (); } - static nano::account result (0); - return result; + + return nano::account::null (); } nano::block_hash nano::ledger::block_source (nano::transaction const & transaction_a, nano::block const & block_a) @@ -968,7 +969,7 @@ nano::block_hash nano::ledger::block_source (nano::transaction const & transacti * passed in exist in the database. This is because it will try * to check account balances to determine if it is a send block. */ - debug_assert (block_a.previous ().is_zero () || store.block_exists (transaction_a, block_a.previous ())); + debug_assert (block_a.previous ().is_zero () || store.block.exists (transaction_a, block_a.previous ())); // If block_a.source () is nonzero, then we have our source. // However, universal blocks will always return zero. @@ -987,7 +988,7 @@ std::pair nano::ledger::hash_root_random (na nano::root root (0); if (!pruning) { - auto block (store.block_random (transaction_a)); + auto block (store.block.random (transaction_a)); hash = block->hash (); root = block->root (); } @@ -999,11 +1000,11 @@ std::pair nano::ledger::hash_root_random (na // Pruned cache cannot guarantee that pruned blocks are already commited if (region < cache.pruned_count) { - hash = store.pruned_random (transaction_a); + hash = store.pruned.random (transaction_a); } if (hash.is_zero ()) { - auto block (store.block_random (transaction_a)); + auto block (store.block.random (transaction_a)); hash = block->hash (); root = block->root (); } @@ -1035,21 +1036,21 @@ nano::uint128_t nano::ledger::weight (nano::account const & account_a) // Rollback blocks until `block_a' doesn't exist or it tries to penetrate the confirmation height bool nano::ledger::rollback (nano::write_transaction const & transaction_a, nano::block_hash const & block_a, std::vector> & list_a) { - debug_assert (store.block_exists (transaction_a, block_a)); + debug_assert (store.block.exists (transaction_a, block_a)); auto account_l (account (transaction_a, block_a)); - auto block_account_height (store.block_account_height (transaction_a, block_a)); + auto block_account_height (store.block.account_height (transaction_a, block_a)); rollback_visitor rollback (transaction_a, *this, list_a); nano::account_info account_info; auto error (false); - while (!error && store.block_exists (transaction_a, block_a)) + while (!error && store.block.exists (transaction_a, block_a)) { nano::confirmation_height_info confirmation_height_info; - store.confirmation_height_get (transaction_a, account_l, confirmation_height_info); + store.confirmation_height.get (transaction_a, account_l, confirmation_height_info); if (block_account_height > confirmation_height_info.height) { - auto latest_error = store.account_get (transaction_a, account_l, account_info); + auto latest_error = store.account.get (transaction_a, account_l, account_info); debug_assert (!latest_error); - auto block (store.block_get (transaction_a, account_info.head)); + auto block (store.block.get (transaction_a, account_info.head)); list_a.push_back (block); block->visit (rollback); error = rollback.error; @@ -1075,21 +1076,21 @@ bool nano::ledger::rollback (nano::write_transaction const & transaction_a, nano // Return account containing hash nano::account nano::ledger::account (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const { - return store.block_account (transaction_a, hash_a); + return store.block.account (transaction_a, hash_a); } nano::account nano::ledger::account_safe (nano::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const { if (!pruning) { - return store.block_account (transaction_a, hash_a); + return store.block.account (transaction_a, hash_a); } else { - auto block (store.block_get (transaction_a, hash_a)); + auto block (store.block.get (transaction_a, hash_a)); if (block != nullptr) { - return store.block_account_calculated (*block); + return store.block.account_calculated (*block); } else { @@ -1102,13 +1103,13 @@ nano::account nano::ledger::account_safe (nano::transaction const & transaction_ // Return amount decrease or increase for block nano::uint128_t nano::ledger::amount (nano::transaction const & transaction_a, nano::account const & account_a) { - release_assert (account_a == network_params.ledger.genesis_account); - return network_params.ledger.genesis_amount; + release_assert (account_a == constants.genesis->account ()); + return nano::dev::constants.genesis_amount; } nano::uint128_t nano::ledger::amount (nano::transaction const & transaction_a, nano::block_hash const & hash_a) { - auto block (store.block_get (transaction_a, hash_a)); + auto block (store.block.get (transaction_a, hash_a)); auto block_balance (balance (transaction_a, hash_a)); auto previous_balance (balance (transaction_a, block->previous ())); return block_balance > previous_balance ? block_balance - previous_balance : previous_balance - block_balance; @@ -1116,18 +1117,19 @@ nano::uint128_t nano::ledger::amount (nano::transaction const & transaction_a, n nano::uint128_t nano::ledger::amount_safe (nano::transaction const & transaction_a, nano::block_hash const & hash_a, bool & error_a) const { - auto block (store.block_get (transaction_a, hash_a)); + auto block (store.block.get (transaction_a, hash_a)); debug_assert (block); auto block_balance (balance (transaction_a, hash_a)); auto previous_balance (balance_safe (transaction_a, block->previous (), error_a)); - return error_a ? 0 : block_balance > previous_balance ? block_balance - previous_balance : previous_balance - block_balance; + return error_a ? 0 : block_balance > previous_balance ? block_balance - previous_balance + : previous_balance - block_balance; } // Return latest block for account nano::block_hash nano::ledger::latest (nano::transaction const & transaction_a, nano::account const & account_a) { nano::account_info info; - auto latest_error (store.account_get (transaction_a, account_a, info)); + auto latest_error (store.account.get (transaction_a, account_a, info)); return latest_error ? 0 : info.head; } @@ -1135,7 +1137,7 @@ nano::block_hash nano::ledger::latest (nano::transaction const & transaction_a, nano::root nano::ledger::latest_root (nano::transaction const & transaction_a, nano::account const & account_a) { nano::account_info info; - if (store.account_get (transaction_a, account_a, info)) + if (store.account.get (transaction_a, account_a, info)) { return account_a; } @@ -1151,7 +1153,7 @@ void nano::ledger::dump_account_chain (nano::account const & account_a, std::ost auto hash (latest (transaction, account_a)); while (!hash.is_zero ()) { - auto block (store.block_get (transaction, hash)); + auto block (store.block.get (transaction, hash)); debug_assert (block != nullptr); stream << hash.to_string () << std::endl; hash = block->previous (); @@ -1162,7 +1164,7 @@ bool nano::ledger::could_fit (nano::transaction const & transaction_a, nano::blo { auto dependencies (dependent_blocks (transaction_a, block_a)); return std::all_of (dependencies.begin (), dependencies.end (), [this, &transaction_a] (nano::block_hash const & hash_a) { - return hash_a.is_zero () || store.block_exists (transaction_a, hash_a); + return hash_a.is_zero () || store.block.exists (transaction_a, hash_a); }); } @@ -1181,7 +1183,7 @@ bool nano::ledger::dependents_confirmed (nano::transaction const & transaction_a bool nano::ledger::is_epoch_link (nano::link const & link_a) const { - return network_params.ledger.epochs.is_epoch_link (link_a); + return constants.epochs.is_epoch_link (link_a); } class dependent_block_visitor : public nano::block_visitor @@ -1204,7 +1206,7 @@ class dependent_block_visitor : public nano::block_visitor } void open_block (nano::open_block const & block_a) override { - if (block_a.source () != ledger.network_params.ledger.genesis_account) + if (block_a.source () != ledger.constants.genesis->account ()) { result[0] = block_a.source (); } @@ -1218,7 +1220,7 @@ class dependent_block_visitor : public nano::block_visitor result[0] = block_a.hashables.previous; result[1] = block_a.hashables.link.as_block_hash (); // ledger.is_send will check the sideband first, if block_a has a loaded sideband the check that previous block exists can be skipped - if (ledger.is_epoch_link (block_a.hashables.link) || ((block_a.has_sideband () || ledger.store.block_exists (transaction, block_a.hashables.previous)) && ledger.is_send (transaction, block_a))) + if (ledger.is_epoch_link (block_a.hashables.link) || ((block_a.has_sideband () || ledger.store.block.exists (transaction, block_a.hashables.previous)) && ledger.is_send (transaction, block_a))) { result[1].clear (); } @@ -1237,12 +1239,12 @@ std::array nano::ledger::dependent_blocks (nano::transactio nano::account const & nano::ledger::epoch_signer (nano::link const & link_a) const { - return network_params.ledger.epochs.signer (network_params.ledger.epochs.epoch (link_a)); + return constants.epochs.signer (constants.epochs.epoch (link_a)); } nano::link const & nano::ledger::epoch_link (nano::epoch epoch_a) const { - return network_params.ledger.epochs.link (epoch_a); + return constants.epochs.link (epoch_a); } void nano::ledger::update_account (nano::write_transaction const & transaction_a, nano::account const & account_a, nano::account_info const & old_a, nano::account_info const & new_a) @@ -1255,15 +1257,15 @@ void nano::ledger::update_account (nano::write_transaction const & transaction_a } if (!old_a.head.is_zero () && old_a.epoch () != new_a.epoch ()) { - // store.account_put won't erase existing entries if they're in different tables - store.account_del (transaction_a, account_a); + // store.account.put won't erase existing entries if they're in different tables + store.account.del (transaction_a, account_a); } - store.account_put (transaction_a, account_a, new_a); + store.account.put (transaction_a, account_a, new_a); } else { - debug_assert (!store.confirmation_height_exists (transaction_a, account_a)); - store.account_del (transaction_a, account_a); + debug_assert (!store.confirmation_height.exists (transaction_a, account_a)); + store.account.del (transaction_a, account_a); debug_assert (cache.account_count > 0); --cache.account_count; } @@ -1276,7 +1278,7 @@ std::shared_ptr nano::ledger::successor (nano::transaction const & if (root_a.previous ().is_zero ()) { nano::account_info info; - if (!store.account_get (transaction_a, root_a.root ().as_account (), info)) + if (!store.account.get (transaction_a, root_a.root ().as_account (), info)) { successor = info.open_block; } @@ -1292,12 +1294,12 @@ std::shared_ptr nano::ledger::successor (nano::transaction const & if (get_from_previous) { - successor = store.block_successor (transaction_a, root_a.previous ()); + successor = store.block.successor (transaction_a, root_a.previous ()); } std::shared_ptr result; if (!successor.is_zero ()) { - result = store.block_get (transaction_a, successor); + result = store.block.get (transaction_a, successor); } debug_assert (successor.is_zero () || result != nullptr); return result; @@ -1305,17 +1307,17 @@ std::shared_ptr nano::ledger::successor (nano::transaction const & std::shared_ptr nano::ledger::forked_block (nano::transaction const & transaction_a, nano::block const & block_a) { - debug_assert (!store.block_exists (transaction_a, block_a.hash ())); + debug_assert (!store.block.exists (transaction_a, block_a.hash ())); auto root (block_a.root ()); - debug_assert (store.block_exists (transaction_a, root.as_block_hash ()) || store.account_exists (transaction_a, root.as_account ())); - auto result (store.block_get (transaction_a, store.block_successor (transaction_a, root.as_block_hash ()))); + debug_assert (store.block.exists (transaction_a, root.as_block_hash ()) || store.account.exists (transaction_a, root.as_account ())); + auto result (store.block.get (transaction_a, store.block.successor (transaction_a, root.as_block_hash ()))); if (result == nullptr) { nano::account_info info; - auto error (store.account_get (transaction_a, root.as_account (), info)); + auto error (store.account.get (transaction_a, root.as_account (), info)); (void)error; debug_assert (!error); - result = store.block_get (transaction_a, info.open_block); + result = store.block.get (transaction_a, info.open_block); debug_assert (result != nullptr); } return result; @@ -1323,15 +1325,15 @@ std::shared_ptr nano::ledger::forked_block (nano::transaction const bool nano::ledger::block_confirmed (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const { - if (store.pruned_exists (transaction_a, hash_a)) + if (store.pruned.exists (transaction_a, hash_a)) { return true; } - auto block = store.block_get (transaction_a, hash_a); + auto block = store.block.get (transaction_a, hash_a); if (block) { nano::confirmation_height_info confirmation_height_info; - store.confirmation_height_get (transaction_a, block->account ().is_zero () ? block->sideband ().account : block->account (), confirmation_height_info); + store.confirmation_height.get (transaction_a, block->account ().is_zero () ? block->sideband ().account : block->account (), confirmation_height_info); auto confirmed (confirmation_height_info.height >= block->sideband ().height); return confirmed; } @@ -1342,13 +1344,13 @@ uint64_t nano::ledger::pruning_action (nano::write_transaction & transaction_a, { uint64_t pruned_count (0); nano::block_hash hash (hash_a); - while (!hash.is_zero () && hash != network_params.ledger.genesis_hash) + while (!hash.is_zero () && hash != constants.genesis->hash ()) { - auto block (store.block_get (transaction_a, hash)); + auto block (store.block.get (transaction_a, hash)); if (block != nullptr) { - store.block_del (transaction_a, hash); - store.pruned_put (transaction_a, hash); + store.block.del (transaction_a, hash); + store.pruned.put (transaction_a, hash); hash = block->previous (); ++pruned_count; ++cache.pruned_count; @@ -1358,7 +1360,7 @@ uint64_t nano::ledger::pruning_action (nano::write_transaction & transaction_a, transaction_a.renew (); } } - else if (store.pruned_exists (transaction_a, hash)) + else if (store.pruned.exists (transaction_a, hash)) { hash = 0; } @@ -1376,7 +1378,7 @@ std::multimap> nano::ledger::unc nano::locked>> result; using result_t = decltype (result)::value_type; - store.accounts_for_each_par ([this, &result] (nano::read_transaction const & transaction_a, nano::store_iterator i, nano::store_iterator n) { + store.account.for_each_par ([this, &result] (nano::read_transaction const & transaction_a, nano::store_iterator i, nano::store_iterator n) { result_t unconfirmed_frontiers_l; for (; i != n; ++i) { @@ -1384,7 +1386,7 @@ std::multimap> nano::ledger::unc auto const & account_info (i->second); nano::confirmation_height_info conf_height_info; - this->store.confirmation_height_get (transaction_a, account, conf_height_info); + this->store.confirmation_height.get (transaction_a, account, conf_height_info); if (account_info.block_count != conf_height_info.height) { @@ -1416,11 +1418,11 @@ bool nano::ledger::migrate_lmdb_to_rocksdb (boost::filesystem::path const & data // Open rocksdb database nano::rocksdb_config rocksdb_config; rocksdb_config.enable = true; - auto rocksdb_store = nano::make_store (logger, data_path_a, false, true, rocksdb_config); + auto rocksdb_store = nano::make_store (logger, data_path_a, nano::dev::constants, false, true, rocksdb_config); if (!rocksdb_store->init_error ()) { - store.blocks_for_each_par ( + store.block.for_each_par ( [&rocksdb_store] (nano::read_transaction const & /*unused*/, auto i, auto n) { for (; i != n; ++i) { @@ -1432,109 +1434,109 @@ bool nano::ledger::migrate_lmdb_to_rocksdb (boost::filesystem::path const & data nano::serialize_block (stream, *i->second.block); i->second.sideband.serialize (stream, i->second.block->type ()); } - rocksdb_store->block_raw_put (rocksdb_transaction, vector, i->first); + rocksdb_store->block.raw_put (rocksdb_transaction, vector, i->first); } }); - store.unchecked_for_each_par ( + store.unchecked.for_each_par ( [&rocksdb_store] (nano::read_transaction const & /*unused*/, auto i, auto n) { for (; i != n; ++i) { auto rocksdb_transaction (rocksdb_store->tx_begin_write ({}, { nano::tables::unchecked })); - rocksdb_store->unchecked_put (rocksdb_transaction, i->first, i->second); + rocksdb_store->unchecked.put (rocksdb_transaction, i->first, i->second); } }); - store.pending_for_each_par ( + store.pending.for_each_par ( [&rocksdb_store] (nano::read_transaction const & /*unused*/, auto i, auto n) { for (; i != n; ++i) { auto rocksdb_transaction (rocksdb_store->tx_begin_write ({}, { nano::tables::pending })); - rocksdb_store->pending_put (rocksdb_transaction, i->first, i->second); + rocksdb_store->pending.put (rocksdb_transaction, i->first, i->second); } }); - store.confirmation_height_for_each_par ( + store.confirmation_height.for_each_par ( [&rocksdb_store] (nano::read_transaction const & /*unused*/, auto i, auto n) { for (; i != n; ++i) { auto rocksdb_transaction (rocksdb_store->tx_begin_write ({}, { nano::tables::confirmation_height })); - rocksdb_store->confirmation_height_put (rocksdb_transaction, i->first, i->second); + rocksdb_store->confirmation_height.put (rocksdb_transaction, i->first, i->second); } }); - store.accounts_for_each_par ( + store.account.for_each_par ( [&rocksdb_store] (nano::read_transaction const & /*unused*/, auto i, auto n) { for (; i != n; ++i) { auto rocksdb_transaction (rocksdb_store->tx_begin_write ({}, { nano::tables::accounts })); - rocksdb_store->account_put (rocksdb_transaction, i->first, i->second); + rocksdb_store->account.put (rocksdb_transaction, i->first, i->second); } }); - store.frontiers_for_each_par ( + store.frontier.for_each_par ( [&rocksdb_store] (nano::read_transaction const & /*unused*/, auto i, auto n) { for (; i != n; ++i) { auto rocksdb_transaction (rocksdb_store->tx_begin_write ({}, { nano::tables::frontiers })); - rocksdb_store->frontier_put (rocksdb_transaction, i->first, i->second); + rocksdb_store->frontier.put (rocksdb_transaction, i->first, i->second); } }); - store.pruned_for_each_par ( + store.pruned.for_each_par ( [&rocksdb_store] (nano::read_transaction const & /*unused*/, auto i, auto n) { for (; i != n; ++i) { auto rocksdb_transaction (rocksdb_store->tx_begin_write ({}, { nano::tables::pruned })); - rocksdb_store->pruned_put (rocksdb_transaction, i->first); + rocksdb_store->pruned.put (rocksdb_transaction, i->first); } }); - store.final_vote_for_each_par ( + store.final_vote.for_each_par ( [&rocksdb_store] (nano::read_transaction const & /*unused*/, auto i, auto n) { for (; i != n; ++i) { auto rocksdb_transaction (rocksdb_store->tx_begin_write ({}, { nano::tables::final_votes })); - rocksdb_store->final_vote_put (rocksdb_transaction, i->first, i->second); + rocksdb_store->final_vote.put (rocksdb_transaction, i->first, i->second); } }); auto lmdb_transaction (store.tx_begin_read ()); - auto version = store.version_get (lmdb_transaction); + auto version = store.version.get (lmdb_transaction); auto rocksdb_transaction (rocksdb_store->tx_begin_write ()); - rocksdb_store->version_put (rocksdb_transaction, version); + rocksdb_store->version.put (rocksdb_transaction, version); - for (auto i (store.online_weight_begin (lmdb_transaction)), n (store.online_weight_end ()); i != n; ++i) + for (auto i (store.online_weight.begin (lmdb_transaction)), n (store.online_weight.end ()); i != n; ++i) { - rocksdb_store->online_weight_put (rocksdb_transaction, i->first, i->second); + rocksdb_store->online_weight.put (rocksdb_transaction, i->first, i->second); } - for (auto i (store.peers_begin (lmdb_transaction)), n (store.peers_end ()); i != n; ++i) + for (auto i (store.peer.begin (lmdb_transaction)), n (store.peer.end ()); i != n; ++i) { - rocksdb_store->peer_put (rocksdb_transaction, i->first); + rocksdb_store->peer.put (rocksdb_transaction, i->first); } // Compare counts - error |= store.unchecked_count (lmdb_transaction) != rocksdb_store->unchecked_count (rocksdb_transaction); - error |= store.peer_count (lmdb_transaction) != rocksdb_store->peer_count (rocksdb_transaction); - error |= store.pruned_count (lmdb_transaction) != rocksdb_store->pruned_count (rocksdb_transaction); - error |= store.final_vote_count (lmdb_transaction) != rocksdb_store->final_vote_count (rocksdb_transaction); - error |= store.online_weight_count (lmdb_transaction) != rocksdb_store->online_weight_count (rocksdb_transaction); - error |= store.version_get (lmdb_transaction) != rocksdb_store->version_get (rocksdb_transaction); + error |= store.unchecked.count (lmdb_transaction) != rocksdb_store->unchecked.count (rocksdb_transaction); + error |= store.peer.count (lmdb_transaction) != rocksdb_store->peer.count (rocksdb_transaction); + error |= store.pruned.count (lmdb_transaction) != rocksdb_store->pruned.count (rocksdb_transaction); + error |= store.final_vote.count (lmdb_transaction) != rocksdb_store->final_vote.count (rocksdb_transaction); + error |= store.online_weight.count (lmdb_transaction) != rocksdb_store->online_weight.count (rocksdb_transaction); + error |= store.version.get (lmdb_transaction) != rocksdb_store->version.get (rocksdb_transaction); // For large tables a random key is used instead and makes sure it exists - auto random_block (store.block_random (lmdb_transaction)); - error |= rocksdb_store->block_get (rocksdb_transaction, random_block->hash ()) == nullptr; + auto random_block (store.block.random (lmdb_transaction)); + error |= rocksdb_store->block.get (rocksdb_transaction, random_block->hash ()) == nullptr; auto account = random_block->account ().is_zero () ? random_block->sideband ().account : random_block->account (); nano::account_info account_info; - error |= rocksdb_store->account_get (rocksdb_transaction, account, account_info); + error |= rocksdb_store->account.get (rocksdb_transaction, account, account_info); // If confirmation height exists in the lmdb ledger for this account it should exist in the rocksdb ledger - nano::confirmation_height_info confirmation_height_info; - if (!store.confirmation_height_get (lmdb_transaction, account, confirmation_height_info)) + nano::confirmation_height_info confirmation_height_info{}; + if (!store.confirmation_height.get (lmdb_transaction, account, confirmation_height_info)) { - error |= rocksdb_store->confirmation_height_get (rocksdb_transaction, account, confirmation_height_info); + error |= rocksdb_store->confirmation_height.get (rocksdb_transaction, account, confirmation_height_info); } } else diff --git a/nano/secure/ledger.hpp b/nano/secure/ledger.hpp index 2dec0af5ea..a27ee1be97 100644 --- a/nano/secure/ledger.hpp +++ b/nano/secure/ledger.hpp @@ -8,7 +8,7 @@ namespace nano { -class block_store; +class store; class stat; class write_transaction; @@ -26,7 +26,7 @@ class uncemented_info class ledger final { public: - ledger (nano::block_store &, nano::stat &, nano::generate_cache const & = nano::generate_cache ()); + ledger (nano::store &, nano::stat &, nano::ledger_constants & constants, nano::generate_cache const & = nano::generate_cache ()); nano::account account (nano::transaction const &, nano::block_hash const &) const; nano::account account_safe (nano::transaction const &, nano::block_hash const &, bool &) const; nano::uint128_t amount (nano::transaction const &, nano::account const &); @@ -68,8 +68,8 @@ class ledger final std::multimap> unconfirmed_frontiers () const; bool migrate_lmdb_to_rocksdb (boost::filesystem::path const &) const; static nano::uint128_t const unit; - nano::network_params network_params; - nano::block_store & store; + nano::ledger_constants & constants; + nano::store & store; nano::ledger_cache cache; nano::stat & stats; std::unordered_map bootstrap_weights; diff --git a/nano/secure/blockstore.cpp b/nano/secure/store.cpp similarity index 67% rename from nano/secure/blockstore.cpp rename to nano/secure/store.cpp index 4431eccdb6..e5cc71b6fe 100644 --- a/nano/secure/blockstore.cpp +++ b/nano/secure/store.cpp @@ -1,7 +1,7 @@ #include -#include +#include -nano::representative_visitor::representative_visitor (nano::transaction const & transaction_a, nano::block_store & store_a) : +nano::representative_visitor::representative_visitor (nano::transaction const & transaction_a, nano::store & store_a) : transaction (transaction_a), store (store_a), result (0) @@ -13,7 +13,7 @@ void nano::representative_visitor::compute (nano::block_hash const & hash_a) current = hash_a; while (result.is_zero ()) { - auto block (store.block_get (transaction, current)); + auto block (store.block.get (transaction, current)); debug_assert (block != nullptr); block->visit (*this); } @@ -104,3 +104,32 @@ bool nano::write_transaction::contains (nano::tables table_a) const { return impl->contains (table_a); } + +// clang-format off +nano::store::store ( + nano::block_store & block_store_a, + nano::frontier_store & frontier_store_a, + nano::account_store & account_store_a, + nano::pending_store & pending_store_a, + nano::unchecked_store & unchecked_store_a, + nano::online_weight_store & online_weight_store_a, + nano::pruned_store & pruned_store_a, + nano::peer_store & peer_store_a, + nano::confirmation_height_store & confirmation_height_store_a, + nano::final_vote_store & final_vote_store_a, + nano::version_store & version_store_a +) : + block (block_store_a), + frontier (frontier_store_a), + account (account_store_a), + pending (pending_store_a), + unchecked (unchecked_store_a), + online_weight (online_weight_store_a), + pruned (pruned_store_a), + peer (peer_store_a), + confirmation_height (confirmation_height_store_a), + final_vote (final_vote_store_a), + version (version_store_a) +{ +} +// clang-format on diff --git a/nano/secure/blockstore.hpp b/nano/secure/store.hpp similarity index 62% rename from nano/secure/blockstore.hpp rename to nano/secure/store.hpp index 2b548d0e2e..5dbbf8f85c 100644 --- a/nano/secure/blockstore.hpp +++ b/nano/secure/store.hpp @@ -438,7 +438,7 @@ class db_val }; class transaction; -class block_store; +class store; /** * Determine the representative for this block @@ -446,7 +446,7 @@ class block_store; class representative_visitor final : public nano::block_visitor { public: - representative_visitor (nano::transaction const & transaction_a, nano::block_store & store_a); + representative_visitor (nano::transaction const & transaction_a, nano::store & store_a); ~representative_visitor () = default; void compute (nano::block_hash const & hash_a); void send_block (nano::send_block const & block_a) override; @@ -455,7 +455,7 @@ class representative_visitor final : public nano::block_visitor void change_block (nano::change_block const & block_a) override; void state_block (nano::state_block const & block_a) override; nano::transaction const & transaction; - nano::block_store & store; + nano::store & store; nano::block_hash current; nano::block_hash result; }; @@ -620,132 +620,234 @@ class write_transaction final : public transaction class ledger_cache; +/** + * Manages frontier storage and iteration + */ +class frontier_store +{ +public: + virtual void put (nano::write_transaction const &, nano::block_hash const &, nano::account const &) = 0; + virtual nano::account get (nano::transaction const &, nano::block_hash const &) const = 0; + virtual void del (nano::write_transaction const &, nano::block_hash const &) = 0; + virtual nano::store_iterator begin (nano::transaction const &) const = 0; + virtual nano::store_iterator begin (nano::transaction const &, nano::block_hash const &) const = 0; + virtual nano::store_iterator end () const = 0; + virtual void for_each_par (std::function, nano::store_iterator)> const & action_a) const = 0; +}; + +/** + * Manages account storage and iteration + */ +class account_store +{ +public: + virtual void put (nano::write_transaction const &, nano::account const &, nano::account_info const &) = 0; + virtual bool get (nano::transaction const &, nano::account const &, nano::account_info &) = 0; + virtual void del (nano::write_transaction const &, nano::account const &) = 0; + virtual bool exists (nano::transaction const &, nano::account const &) = 0; + virtual size_t count (nano::transaction const &) = 0; + virtual nano::store_iterator begin (nano::transaction const &, nano::account const &) const = 0; + virtual nano::store_iterator begin (nano::transaction const &) const = 0; + virtual nano::store_iterator rbegin (nano::transaction const &) const = 0; + virtual nano::store_iterator end () const = 0; + virtual void for_each_par (std::function, nano::store_iterator)> const &) const = 0; +}; + +/** + * Manages pending storage and iteration + */ +class pending_store +{ +public: + virtual void put (nano::write_transaction const &, nano::pending_key const &, nano::pending_info const &) = 0; + virtual void del (nano::write_transaction const &, nano::pending_key const &) = 0; + virtual bool get (nano::transaction const &, nano::pending_key const &, nano::pending_info &) = 0; + virtual bool exists (nano::transaction const &, nano::pending_key const &) = 0; + virtual bool any (nano::transaction const &, nano::account const &) = 0; + virtual nano::store_iterator begin (nano::transaction const &, nano::pending_key const &) const = 0; + virtual nano::store_iterator begin (nano::transaction const &) const = 0; + virtual nano::store_iterator end () const = 0; + virtual void for_each_par (std::function, nano::store_iterator)> const & action_a) const = 0; +}; + +/** + * Manages peer storage and iteration + */ +class peer_store +{ +public: + virtual void put (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) = 0; + virtual void del (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) = 0; + virtual bool exists (nano::transaction const & transaction_a, nano::endpoint_key const & endpoint_a) const = 0; + virtual size_t count (nano::transaction const & transaction_a) const = 0; + virtual void clear (nano::write_transaction const & transaction_a) = 0; + virtual nano::store_iterator begin (nano::transaction const & transaction_a) const = 0; + virtual nano::store_iterator end () const = 0; +}; + +/** + * Manages online weight storage and iteration + */ +class online_weight_store +{ +public: + virtual void put (nano::write_transaction const &, uint64_t, nano::amount const &) = 0; + virtual void del (nano::write_transaction const &, uint64_t) = 0; + virtual nano::store_iterator begin (nano::transaction const &) const = 0; + virtual nano::store_iterator rbegin (nano::transaction const &) const = 0; + virtual nano::store_iterator end () const = 0; + virtual size_t count (nano::transaction const &) const = 0; + virtual void clear (nano::write_transaction const &) = 0; +}; + +/** + * Manages pruned storage and iteration + */ +class pruned_store +{ +public: + virtual void put (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a) = 0; + virtual void del (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a) = 0; + virtual bool exists (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const = 0; + virtual nano::block_hash random (nano::transaction const & transaction_a) = 0; + virtual size_t count (nano::transaction const & transaction_a) const = 0; + virtual void clear (nano::write_transaction const &) = 0; + virtual nano::store_iterator begin (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const = 0; + virtual nano::store_iterator begin (nano::transaction const & transaction_a) const = 0; + virtual nano::store_iterator end () const = 0; + virtual void for_each_par (std::function, nano::store_iterator)> const & action_a) const = 0; +}; + +/** + * Manages confirmation height storage and iteration + */ +class confirmation_height_store +{ +public: + virtual void put (nano::write_transaction const & transaction_a, nano::account const & account_a, nano::confirmation_height_info const & confirmation_height_info_a) = 0; + virtual bool get (nano::transaction const & transaction_a, nano::account const & account_a, nano::confirmation_height_info & confirmation_height_info_a) = 0; + virtual bool exists (nano::transaction const & transaction_a, nano::account const & account_a) const = 0; + virtual void del (nano::write_transaction const & transaction_a, nano::account const & account_a) = 0; + virtual uint64_t count (nano::transaction const & transaction_a) = 0; + virtual void clear (nano::write_transaction const &, nano::account const &) = 0; + virtual void clear (nano::write_transaction const &) = 0; + virtual nano::store_iterator begin (nano::transaction const & transaction_a, nano::account const & account_a) const = 0; + virtual nano::store_iterator begin (nano::transaction const & transaction_a) const = 0; + virtual nano::store_iterator end () const = 0; + virtual void for_each_par (std::function, nano::store_iterator)> const &) const = 0; +}; + +/** + * Manages unchecked storage and iteration + */ +class unchecked_store +{ +public: + virtual void clear (nano::write_transaction const &) = 0; + virtual void put (nano::write_transaction const &, nano::unchecked_key const &, nano::unchecked_info const &) = 0; + virtual void put (nano::write_transaction const &, nano::block_hash const &, std::shared_ptr const &) = 0; + virtual std::vector get (nano::transaction const &, nano::block_hash const &) = 0; + virtual bool exists (nano::transaction const & transaction_a, nano::unchecked_key const & unchecked_key_a) = 0; + virtual void del (nano::write_transaction const &, nano::unchecked_key const &) = 0; + virtual nano::store_iterator begin (nano::transaction const &) const = 0; + virtual nano::store_iterator begin (nano::transaction const &, nano::unchecked_key const &) const = 0; + virtual nano::store_iterator end () const = 0; + virtual size_t count (nano::transaction const &) = 0; + virtual void for_each_par (std::function, nano::store_iterator)> const & action_a) const = 0; +}; + +/** + * Manages final vote storage and iteration + */ +class final_vote_store +{ +public: + virtual bool put (nano::write_transaction const & transaction_a, nano::qualified_root const & root_a, nano::block_hash const & hash_a) = 0; + virtual std::vector get (nano::transaction const & transaction_a, nano::root const & root_a) = 0; + virtual void del (nano::write_transaction const & transaction_a, nano::root const & root_a) = 0; + virtual size_t count (nano::transaction const & transaction_a) const = 0; + virtual void clear (nano::write_transaction const &, nano::root const &) = 0; + virtual void clear (nano::write_transaction const &) = 0; + virtual nano::store_iterator begin (nano::transaction const & transaction_a, nano::qualified_root const & root_a) const = 0; + virtual nano::store_iterator begin (nano::transaction const & transaction_a) const = 0; + virtual nano::store_iterator end () const = 0; + virtual void for_each_par (std::function, nano::store_iterator)> const & action_a) const = 0; +}; + +/** + * Manages version storage + */ +class version_store +{ +public: + virtual void put (nano::write_transaction const &, int) = 0; + virtual int get (nano::transaction const &) const = 0; +}; + /** * Manages block storage and iteration */ class block_store { public: - virtual ~block_store () = default; - virtual void initialize (nano::write_transaction const &, nano::genesis const &, nano::ledger_cache &) = 0; - virtual void block_put (nano::write_transaction const &, nano::block_hash const &, nano::block const &) = 0; - virtual void block_raw_put (nano::write_transaction const &, std::vector const &, nano::block_hash const &) = 0; - virtual nano::block_hash block_successor (nano::transaction const &, nano::block_hash const &) const = 0; - virtual void block_successor_clear (nano::write_transaction const &, nano::block_hash const &) = 0; - virtual std::shared_ptr block_get (nano::transaction const &, nano::block_hash const &) const = 0; - virtual std::shared_ptr block_get_no_sideband (nano::transaction const &, nano::block_hash const &) const = 0; - virtual std::shared_ptr block_random (nano::transaction const &) = 0; - virtual void block_del (nano::write_transaction const &, nano::block_hash const &) = 0; - virtual bool block_exists (nano::transaction const &, nano::block_hash const &) = 0; - virtual uint64_t block_count (nano::transaction const &) = 0; + virtual void put (nano::write_transaction const &, nano::block_hash const &, nano::block const &) = 0; + virtual void raw_put (nano::write_transaction const &, std::vector const &, nano::block_hash const &) = 0; + virtual nano::block_hash successor (nano::transaction const &, nano::block_hash const &) const = 0; + virtual void successor_clear (nano::write_transaction const &, nano::block_hash const &) = 0; + virtual std::shared_ptr get (nano::transaction const &, nano::block_hash const &) const = 0; + virtual std::shared_ptr get_no_sideband (nano::transaction const &, nano::block_hash const &) const = 0; + virtual std::shared_ptr random (nano::transaction const &) = 0; + virtual void del (nano::write_transaction const &, nano::block_hash const &) = 0; + virtual bool exists (nano::transaction const &, nano::block_hash const &) = 0; + virtual uint64_t count (nano::transaction const &) = 0; + virtual nano::account account (nano::transaction const &, nano::block_hash const &) const = 0; + virtual nano::account account_calculated (nano::block const &) const = 0; + virtual nano::store_iterator begin (nano::transaction const &, nano::block_hash const &) const = 0; + virtual nano::store_iterator begin (nano::transaction const &) const = 0; + virtual nano::store_iterator end () const = 0; + virtual nano::uint128_t balance (nano::transaction const &, nano::block_hash const &) = 0; + virtual nano::uint128_t balance_calculated (std::shared_ptr const &) const = 0; + virtual nano::epoch version (nano::transaction const &, nano::block_hash const &) = 0; + virtual void for_each_par (std::function, nano::store_iterator)> const & action_a) const = 0; + virtual uint64_t account_height (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const = 0; +}; + +/** + * Store manager + */ +class store +{ +public: + // clang-format off + explicit store ( + nano::block_store &, + nano::frontier_store &, + nano::account_store &, + nano::pending_store &, + nano::unchecked_store &, + nano::online_weight_store &, + nano::pruned_store &, + nano::peer_store &, + nano::confirmation_height_store &, + nano::final_vote_store &, + nano::version_store & + ); + // clang-format on + virtual ~store () = default; + virtual void initialize (nano::write_transaction const &, nano::ledger_cache &) = 0; virtual bool root_exists (nano::transaction const &, nano::root const &) = 0; - virtual nano::account block_account (nano::transaction const &, nano::block_hash const &) const = 0; - virtual nano::account block_account_calculated (nano::block const &) const = 0; - virtual nano::store_iterator blocks_begin (nano::transaction const &, nano::block_hash const &) const = 0; - virtual nano::store_iterator blocks_begin (nano::transaction const &) const = 0; - virtual nano::store_iterator blocks_end () const = 0; - - virtual void frontier_put (nano::write_transaction const &, nano::block_hash const &, nano::account const &) = 0; - virtual nano::account frontier_get (nano::transaction const &, nano::block_hash const &) const = 0; - virtual void frontier_del (nano::write_transaction const &, nano::block_hash const &) = 0; - virtual nano::store_iterator frontiers_begin (nano::transaction const &) const = 0; - virtual nano::store_iterator frontiers_begin (nano::transaction const &, nano::block_hash const &) const = 0; - virtual nano::store_iterator frontiers_end () const = 0; - - virtual void account_put (nano::write_transaction const &, nano::account const &, nano::account_info const &) = 0; - virtual bool account_get (nano::transaction const &, nano::account const &, nano::account_info &) = 0; - virtual void account_del (nano::write_transaction const &, nano::account const &) = 0; - virtual bool account_exists (nano::transaction const &, nano::account const &) = 0; - virtual size_t account_count (nano::transaction const &) = 0; - virtual nano::store_iterator accounts_begin (nano::transaction const &, nano::account const &) const = 0; - virtual nano::store_iterator accounts_begin (nano::transaction const &) const = 0; - virtual nano::store_iterator accounts_rbegin (nano::transaction const &) const = 0; - virtual nano::store_iterator accounts_end () const = 0; - - virtual void pending_put (nano::write_transaction const &, nano::pending_key const &, nano::pending_info const &) = 0; - virtual void pending_del (nano::write_transaction const &, nano::pending_key const &) = 0; - virtual bool pending_get (nano::transaction const &, nano::pending_key const &, nano::pending_info &) = 0; - virtual bool pending_exists (nano::transaction const &, nano::pending_key const &) = 0; - virtual bool pending_any (nano::transaction const &, nano::account const &) = 0; - virtual nano::store_iterator pending_begin (nano::transaction const &, nano::pending_key const &) const = 0; - virtual nano::store_iterator pending_begin (nano::transaction const &) const = 0; - virtual nano::store_iterator pending_end () const = 0; - - virtual nano::uint128_t block_balance (nano::transaction const &, nano::block_hash const &) = 0; - virtual nano::uint128_t block_balance_calculated (std::shared_ptr const &) const = 0; - virtual nano::epoch block_version (nano::transaction const &, nano::block_hash const &) = 0; - - virtual void unchecked_clear (nano::write_transaction const &) = 0; - virtual void unchecked_put (nano::write_transaction const &, nano::unchecked_key const &, nano::unchecked_info const &) = 0; - virtual void unchecked_put (nano::write_transaction const &, nano::block_hash const &, std::shared_ptr const &) = 0; - virtual std::vector unchecked_get (nano::transaction const &, nano::block_hash const &) = 0; - virtual bool unchecked_exists (nano::transaction const & transaction_a, nano::unchecked_key const & unchecked_key_a) = 0; - virtual void unchecked_del (nano::write_transaction const &, nano::unchecked_key const &) = 0; - virtual nano::store_iterator unchecked_begin (nano::transaction const &) const = 0; - virtual nano::store_iterator unchecked_begin (nano::transaction const &, nano::unchecked_key const &) const = 0; - virtual nano::store_iterator unchecked_end () const = 0; - virtual size_t unchecked_count (nano::transaction const &) = 0; - - virtual void online_weight_put (nano::write_transaction const &, uint64_t, nano::amount const &) = 0; - virtual void online_weight_del (nano::write_transaction const &, uint64_t) = 0; - virtual nano::store_iterator online_weight_begin (nano::transaction const &) const = 0; - virtual nano::store_iterator online_weight_rbegin (nano::transaction const &) const = 0; - virtual nano::store_iterator online_weight_end () const = 0; - virtual size_t online_weight_count (nano::transaction const &) const = 0; - virtual void online_weight_clear (nano::write_transaction const &) = 0; - - virtual void version_put (nano::write_transaction const &, int) = 0; - virtual int version_get (nano::transaction const &) const = 0; - - virtual void pruned_put (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a) = 0; - virtual void pruned_del (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a) = 0; - virtual bool pruned_exists (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const = 0; - virtual nano::block_hash pruned_random (nano::transaction const & transaction_a) = 0; - virtual size_t pruned_count (nano::transaction const & transaction_a) const = 0; - virtual void pruned_clear (nano::write_transaction const &) = 0; - virtual nano::store_iterator pruned_begin (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const = 0; - virtual nano::store_iterator pruned_begin (nano::transaction const & transaction_a) const = 0; - virtual nano::store_iterator pruned_end () const = 0; - - virtual void peer_put (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) = 0; - virtual void peer_del (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) = 0; - virtual bool peer_exists (nano::transaction const & transaction_a, nano::endpoint_key const & endpoint_a) const = 0; - virtual size_t peer_count (nano::transaction const & transaction_a) const = 0; - virtual void peer_clear (nano::write_transaction const & transaction_a) = 0; - virtual nano::store_iterator peers_begin (nano::transaction const & transaction_a) const = 0; - virtual nano::store_iterator peers_end () const = 0; - - virtual void confirmation_height_put (nano::write_transaction const & transaction_a, nano::account const & account_a, nano::confirmation_height_info const & confirmation_height_info_a) = 0; - virtual bool confirmation_height_get (nano::transaction const & transaction_a, nano::account const & account_a, nano::confirmation_height_info & confirmation_height_info_a) = 0; - virtual bool confirmation_height_exists (nano::transaction const & transaction_a, nano::account const & account_a) const = 0; - virtual void confirmation_height_del (nano::write_transaction const & transaction_a, nano::account const & account_a) = 0; - virtual uint64_t confirmation_height_count (nano::transaction const & transaction_a) = 0; - virtual void confirmation_height_clear (nano::write_transaction const &, nano::account const &) = 0; - virtual void confirmation_height_clear (nano::write_transaction const &) = 0; - virtual nano::store_iterator confirmation_height_begin (nano::transaction const & transaction_a, nano::account const & account_a) const = 0; - virtual nano::store_iterator confirmation_height_begin (nano::transaction const & transaction_a) const = 0; - virtual nano::store_iterator confirmation_height_end () const = 0; - - virtual void accounts_for_each_par (std::function, nano::store_iterator)> const &) const = 0; - virtual void confirmation_height_for_each_par (std::function, nano::store_iterator)> const &) const = 0; - virtual void pending_for_each_par (std::function, nano::store_iterator)> const & action_a) const = 0; - virtual void unchecked_for_each_par (std::function, nano::store_iterator)> const & action_a) const = 0; - virtual void pruned_for_each_par (std::function, nano::store_iterator)> const & action_a) const = 0; - virtual void blocks_for_each_par (std::function, nano::store_iterator)> const & action_a) const = 0; - virtual void frontiers_for_each_par (std::function, nano::store_iterator)> const & action_a) const = 0; - virtual void final_vote_for_each_par (std::function, nano::store_iterator)> const & action_a) const = 0; - - virtual uint64_t block_account_height (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const = 0; - - virtual bool final_vote_put (nano::write_transaction const & transaction_a, nano::qualified_root const & root_a, nano::block_hash const & hash_a) = 0; - virtual std::vector final_vote_get (nano::transaction const & transaction_a, nano::root const & root_a) = 0; - virtual void final_vote_del (nano::write_transaction const & transaction_a, nano::root const & root_a) = 0; - virtual size_t final_vote_count (nano::transaction const & transaction_a) const = 0; - virtual void final_vote_clear (nano::write_transaction const &, nano::root const &) = 0; - virtual void final_vote_clear (nano::write_transaction const &) = 0; - virtual nano::store_iterator final_vote_begin (nano::transaction const & transaction_a, nano::qualified_root const & root_a) const = 0; - virtual nano::store_iterator final_vote_begin (nano::transaction const & transaction_a) const = 0; - virtual nano::store_iterator final_vote_end () const = 0; + + block_store & block; + frontier_store & frontier; + account_store & account; + pending_store & pending; + unchecked_store & unchecked; + online_weight_store & online_weight; + pruned_store & pruned; + peer_store & peer; + confirmation_height_store & confirmation_height; + final_vote_store & final_vote; + version_store & version; virtual unsigned max_block_write_batch_num () const = 0; @@ -767,7 +869,7 @@ class block_store virtual std::string vendor_get () const = 0; }; -std::unique_ptr make_store (nano::logger_mt & logger, boost::filesystem::path const & path, bool open_read_only = false, bool add_db_postfix = false, nano::rocksdb_config const & rocksdb_config = nano::rocksdb_config{}, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), nano::lmdb_config const & lmdb_config_a = nano::lmdb_config{}, bool backup_before_upgrade = false); +std::unique_ptr make_store (nano::logger_mt & logger, boost::filesystem::path const & path, nano::ledger_constants & constants, bool open_read_only = false, bool add_db_postfix = false, nano::rocksdb_config const & rocksdb_config = nano::rocksdb_config{}, nano::txn_tracking_config const & txn_tracking_config_a = nano::txn_tracking_config{}, std::chrono::milliseconds block_processor_batch_max_time_a = std::chrono::milliseconds (5000), nano::lmdb_config const & lmdb_config_a = nano::lmdb_config{}, bool backup_before_upgrade = false); } namespace std diff --git a/nano/secure/store/account_store_partial.hpp b/nano/secure/store/account_store_partial.hpp new file mode 100644 index 0000000000..727ba5d7f0 --- /dev/null +++ b/nano/secure/store/account_store_partial.hpp @@ -0,0 +1,101 @@ +#pragma once + +#include + +namespace +{ +template +void parallel_traversal (std::function const & action); +} + +namespace nano +{ +template +class store_partial; + +template +void release_assert_success (store_partial const &, int const); + +template +class account_store_partial : public account_store +{ +private: + nano::store_partial & store; + + friend void release_assert_success (store_partial const &, int const); + +public: + explicit account_store_partial (nano::store_partial & store_a) : + store (store_a){}; + + void put (nano::write_transaction const & transaction_a, nano::account const & account_a, nano::account_info const & info_a) override + { + // Check we are still in sync with other tables + nano::db_val info (info_a); + auto status = store.put (transaction_a, tables::accounts, account_a, info); + release_assert_success (store, status); + } + + bool get (nano::transaction const & transaction_a, nano::account const & account_a, nano::account_info & info_a) override + { + nano::db_val value; + nano::db_val account (account_a); + auto status1 (store.get (transaction_a, tables::accounts, account, value)); + release_assert (store.success (status1) || store.not_found (status1)); + bool result (true); + if (store.success (status1)) + { + nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); + result = info_a.deserialize (stream); + } + return result; + } + + void del (nano::write_transaction const & transaction_a, nano::account const & account_a) override + { + auto status = store.del (transaction_a, tables::accounts, account_a); + release_assert_success (store, status); + } + + bool exists (nano::transaction const & transaction_a, nano::account const & account_a) override + { + auto iterator (begin (transaction_a, account_a)); + return iterator != end () && nano::account (iterator->first) == account_a; + } + + size_t count (nano::transaction const & transaction_a) override + { + return store.count (transaction_a, tables::accounts); + } + + nano::store_iterator begin (nano::transaction const & transaction_a, nano::account const & account_a) const override + { + return store.template make_iterator (transaction_a, tables::accounts, nano::db_val (account_a)); + } + + nano::store_iterator begin (nano::transaction const & transaction_a) const override + { + return store.template make_iterator (transaction_a, tables::accounts); + } + + nano::store_iterator rbegin (nano::transaction const & transaction_a) const override + { + return store.template make_iterator (transaction_a, tables::accounts, false); + } + + nano::store_iterator end () const override + { + return nano::store_iterator (nullptr); + } + + void for_each_par (std::function, nano::store_iterator)> const & action_a) const override + { + parallel_traversal ( + [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { + auto transaction (this->store.tx_begin_read ()); + action_a (transaction, this->begin (transaction, start), !is_last ? this->begin (transaction, end) : this->end ()); + }); + } +}; + +} diff --git a/nano/secure/store/block_store_partial.hpp b/nano/secure/store/block_store_partial.hpp new file mode 100644 index 0000000000..a8461af5a0 --- /dev/null +++ b/nano/secure/store/block_store_partial.hpp @@ -0,0 +1,313 @@ +#pragma once + +#include + +namespace +{ +template +void parallel_traversal (std::function const & action); +} + +namespace nano +{ +template +class store_partial; + +template +class block_predecessor_set; + +template +void release_assert_success (store_partial const &, int const); + +template +class block_store_partial : public block_store +{ +protected: + nano::store_partial & store; + + friend class nano::block_predecessor_set; + +public: + explicit block_store_partial (nano::store_partial & store_a) : + store (store_a){}; + + void put (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a, nano::block const & block_a) override + { + debug_assert (block_a.sideband ().successor.is_zero () || exists (transaction_a, block_a.sideband ().successor)); + std::vector vector; + { + nano::vectorstream stream (vector); + nano::serialize_block (stream, block_a); + block_a.sideband ().serialize (stream, block_a.type ()); + } + raw_put (transaction_a, vector, hash_a); + nano::block_predecessor_set predecessor (transaction_a, *this); + block_a.visit (predecessor); + debug_assert (block_a.previous ().is_zero () || successor (transaction_a, block_a.previous ()) == hash_a); + } + + void raw_put (nano::write_transaction const & transaction_a, std::vector const & data, nano::block_hash const & hash_a) override + { + nano::db_val value{ data.size (), (void *)data.data () }; + auto status = store.put (transaction_a, tables::blocks, hash_a, value); + release_assert_success (store, status); + } + + nano::block_hash successor (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override + { + auto value (block_raw_get (transaction_a, hash_a)); + nano::block_hash result; + if (value.size () != 0) + { + debug_assert (value.size () >= result.bytes.size ()); + auto type = block_type_from_raw (value.data ()); + nano::bufferstream stream (reinterpret_cast (value.data ()) + block_successor_offset (transaction_a, value.size (), type), result.bytes.size ()); + auto error (nano::try_read (stream, result.bytes)); + (void)error; + debug_assert (!error); + } + else + { + result.clear (); + } + return result; + } + + void successor_clear (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a) override + { + auto value (block_raw_get (transaction_a, hash_a)); + debug_assert (value.size () != 0); + auto type = block_type_from_raw (value.data ()); + std::vector data (static_cast (value.data ()), static_cast (value.data ()) + value.size ()); + std::fill_n (data.begin () + block_successor_offset (transaction_a, value.size (), type), sizeof (nano::block_hash), uint8_t{ 0 }); + raw_put (transaction_a, data, hash_a); + } + + std::shared_ptr get (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override + { + auto value (block_raw_get (transaction_a, hash_a)); + std::shared_ptr result; + if (value.size () != 0) + { + nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); + nano::block_type type; + auto error (try_read (stream, type)); + release_assert (!error); + result = nano::deserialize_block (stream, type); + release_assert (result != nullptr); + nano::block_sideband sideband; + error = (sideband.deserialize (stream, type)); + release_assert (!error); + result->sideband_set (sideband); + } + return result; + } + + std::shared_ptr get_no_sideband (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override + { + auto value (block_raw_get (transaction_a, hash_a)); + std::shared_ptr result; + if (value.size () != 0) + { + nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); + result = nano::deserialize_block (stream); + debug_assert (result != nullptr); + } + return result; + } + + std::shared_ptr random (nano::transaction const & transaction_a) override + { + nano::block_hash hash; + nano::random_pool::generate_block (hash.bytes.data (), hash.bytes.size ()); + auto existing = store.template make_iterator> (transaction_a, tables::blocks, nano::db_val (hash)); + auto end (nano::store_iterator> (nullptr)); + if (existing == end) + { + existing = store.template make_iterator> (transaction_a, tables::blocks); + } + debug_assert (existing != end); + return existing->second; + } + + void del (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a) override + { + auto status = store.del (transaction_a, tables::blocks, hash_a); + release_assert_success (store, status); + } + + bool exists (nano::transaction const & transaction_a, nano::block_hash const & hash_a) override + { + auto junk = block_raw_get (transaction_a, hash_a); + return junk.size () != 0; + } + + uint64_t count (nano::transaction const & transaction_a) override + { + return store.count (transaction_a, tables::blocks); + } + + nano::account account (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override + { + auto block (get (transaction_a, hash_a)); + debug_assert (block != nullptr); + return account_calculated (*block); + } + + nano::account account_calculated (nano::block const & block_a) const override + { + debug_assert (block_a.has_sideband ()); + nano::account result (block_a.account ()); + if (result.is_zero ()) + { + result = block_a.sideband ().account; + } + debug_assert (!result.is_zero ()); + return result; + } + + nano::store_iterator begin (nano::transaction const & transaction_a) const override + { + return store.template make_iterator (transaction_a, tables::blocks); + } + + nano::store_iterator begin (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override + { + return store.template make_iterator (transaction_a, tables::blocks, nano::db_val (hash_a)); + } + + nano::store_iterator end () const override + { + return nano::store_iterator (nullptr); + } + + nano::uint128_t balance (nano::transaction const & transaction_a, nano::block_hash const & hash_a) override + { + auto block (get (transaction_a, hash_a)); + release_assert (block); + nano::uint128_t result (balance_calculated (block)); + return result; + } + + nano::uint128_t balance_calculated (std::shared_ptr const & block_a) const override + { + nano::uint128_t result; + switch (block_a->type ()) + { + case nano::block_type::open: + case nano::block_type::receive: + case nano::block_type::change: + result = block_a->sideband ().balance.number (); + break; + case nano::block_type::send: + result = boost::polymorphic_downcast (block_a.get ())->hashables.balance.number (); + break; + case nano::block_type::state: + result = boost::polymorphic_downcast (block_a.get ())->hashables.balance.number (); + break; + case nano::block_type::invalid: + case nano::block_type::not_a_block: + release_assert (false); + break; + } + return result; + } + + nano::epoch version (nano::transaction const & transaction_a, nano::block_hash const & hash_a) override + { + auto block = get (transaction_a, hash_a); + if (block && block->type () == nano::block_type::state) + { + return block->sideband ().details.epoch; + } + + return nano::epoch::epoch_0; + } + + void for_each_par (std::function, nano::store_iterator)> const & action_a) const override + { + parallel_traversal ( + [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { + auto transaction (this->store.tx_begin_read ()); + action_a (transaction, this->begin (transaction, start), !is_last ? this->begin (transaction, end) : this->end ()); + }); + } + + // Converts a block hash to a block height + uint64_t account_height (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override + { + auto block = get (transaction_a, hash_a); + return block->sideband ().height; + } + +protected: + nano::db_val block_raw_get (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const + { + nano::db_val result; + auto status = store.get (transaction_a, tables::blocks, hash_a, result); + release_assert (store.success (status) || store.not_found (status)); + return result; + } + + size_t block_successor_offset (nano::transaction const & transaction_a, size_t entry_size_a, nano::block_type type_a) const + { + return entry_size_a - nano::block_sideband::size (type_a); + } + + static nano::block_type block_type_from_raw (void * data_a) + { + // The block type is the first byte + return static_cast ((reinterpret_cast (data_a))[0]); + } +}; + +/** + * Fill in our predecessors + */ +template +class block_predecessor_set : public nano::block_visitor +{ +public: + block_predecessor_set (nano::write_transaction const & transaction_a, nano::block_store_partial & block_store_a) : + transaction (transaction_a), + block_store (block_store_a) + { + } + virtual ~block_predecessor_set () = default; + void fill_value (nano::block const & block_a) + { + auto hash (block_a.hash ()); + auto value (block_store.block_raw_get (transaction, block_a.previous ())); + debug_assert (value.size () != 0); + auto type = block_store.block_type_from_raw (value.data ()); + std::vector data (static_cast (value.data ()), static_cast (value.data ()) + value.size ()); + std::copy (hash.bytes.begin (), hash.bytes.end (), data.begin () + block_store.block_successor_offset (transaction, value.size (), type)); + block_store.raw_put (transaction, data, block_a.previous ()); + } + void send_block (nano::send_block const & block_a) override + { + fill_value (block_a); + } + void receive_block (nano::receive_block const & block_a) override + { + fill_value (block_a); + } + void open_block (nano::open_block const & block_a) override + { + // Open blocks don't have a predecessor + } + void change_block (nano::change_block const & block_a) override + { + fill_value (block_a); + } + void state_block (nano::state_block const & block_a) override + { + if (!block_a.previous ().is_zero ()) + { + fill_value (block_a); + } + } + nano::write_transaction const & transaction; + nano::block_store_partial & block_store; +}; +} diff --git a/nano/secure/store/confirmation_height_store_partial.hpp b/nano/secure/store/confirmation_height_store_partial.hpp new file mode 100644 index 0000000000..3eb4fd609f --- /dev/null +++ b/nano/secure/store/confirmation_height_store_partial.hpp @@ -0,0 +1,109 @@ +#pragma once + +#include + +namespace +{ +template +void parallel_traversal (std::function const & action); +} + +namespace nano +{ +template +class store_partial; + +template +void release_assert_success (store_partial const &, int const); + +template +class confirmation_height_store_partial : public confirmation_height_store +{ +private: + nano::store_partial & store; + + friend void release_assert_success (store_partial const &, int const); + +public: + explicit confirmation_height_store_partial (nano::store_partial & store_a) : + store (store_a){}; + + void put (nano::write_transaction const & transaction_a, nano::account const & account_a, nano::confirmation_height_info const & confirmation_height_info_a) override + { + nano::db_val confirmation_height_info (confirmation_height_info_a); + auto status = store.put (transaction_a, tables::confirmation_height, account_a, confirmation_height_info); + release_assert_success (store, status); + } + + bool get (nano::transaction const & transaction_a, nano::account const & account_a, nano::confirmation_height_info & confirmation_height_info_a) override + { + nano::db_val value; + auto status = store.get (transaction_a, tables::confirmation_height, nano::db_val (account_a), value); + release_assert (store.success (status) || store.not_found (status)); + bool result (true); + if (store.success (status)) + { + nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); + result = confirmation_height_info_a.deserialize (stream); + } + if (result) + { + confirmation_height_info_a.height = 0; + confirmation_height_info_a.frontier = 0; + } + + return result; + } + + bool exists (nano::transaction const & transaction_a, nano::account const & account_a) const override + { + return store.exists (transaction_a, tables::confirmation_height, nano::db_val (account_a)); + } + + void del (nano::write_transaction const & transaction_a, nano::account const & account_a) override + { + auto status (store.del (transaction_a, tables::confirmation_height, nano::db_val (account_a))); + release_assert_success (store, status); + } + + uint64_t count (nano::transaction const & transaction_a) override + { + return store.count (transaction_a, tables::confirmation_height); + } + + void clear (nano::write_transaction const & transaction_a, nano::account const & account_a) override + { + del (transaction_a, account_a); + } + + void clear (nano::write_transaction const & transaction_a) override + { + store.drop (transaction_a, nano::tables::confirmation_height); + } + + nano::store_iterator begin (nano::transaction const & transaction_a, nano::account const & account_a) const override + { + return store.template make_iterator (transaction_a, tables::confirmation_height, nano::db_val (account_a)); + } + + nano::store_iterator begin (nano::transaction const & transaction_a) const override + { + return store.template make_iterator (transaction_a, tables::confirmation_height); + } + + nano::store_iterator end () const override + { + return nano::store_iterator (nullptr); + } + + void for_each_par (std::function, nano::store_iterator)> const & action_a) const override + { + parallel_traversal ( + [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { + auto transaction (this->store.tx_begin_read ()); + action_a (transaction, this->begin (transaction, start), !is_last ? this->begin (transaction, end) : this->end ()); + }); + } +}; + +} diff --git a/nano/secure/store/final_vote_store_partial.hpp b/nano/secure/store/final_vote_store_partial.hpp new file mode 100644 index 0000000000..b0f450c9e1 --- /dev/null +++ b/nano/secure/store/final_vote_store_partial.hpp @@ -0,0 +1,115 @@ +#pragma once + +#include + +namespace +{ +template +void parallel_traversal (std::function const & action); +} + +namespace nano +{ +template +class store_partial; + +template +void release_assert_success (store_partial const & store, int const status); + +template +class final_vote_store_partial : public final_vote_store +{ +private: + nano::store_partial & store; + + friend void release_assert_success (store_partial const &, int const); + +public: + explicit final_vote_store_partial (nano::store_partial & store_a) : + store (store_a){}; + + bool put (nano::write_transaction const & transaction_a, nano::qualified_root const & root_a, nano::block_hash const & hash_a) override + { + nano::db_val value; + auto status = store.get (transaction_a, tables::final_votes, nano::db_val (root_a), value); + release_assert (store.success (status) || store.not_found (status)); + bool result (true); + if (store.success (status)) + { + result = static_cast (value) == hash_a; + } + else + { + status = store.put (transaction_a, tables::final_votes, root_a, hash_a); + release_assert_success (store, status); + } + return result; + } + + std::vector get (nano::transaction const & transaction_a, nano::root const & root_a) override + { + std::vector result; + nano::qualified_root key_start (root_a.raw, 0); + for (auto i (begin (transaction_a, key_start)), n (end ()); i != n && nano::qualified_root (i->first).root () == root_a; ++i) + { + result.push_back (i->second); + } + return result; + } + + void del (nano::write_transaction const & transaction_a, nano::root const & root_a) override + { + std::vector final_vote_qualified_roots; + for (auto i (begin (transaction_a, nano::qualified_root (root_a.raw, 0))), n (end ()); i != n && nano::qualified_root (i->first).root () == root_a; ++i) + { + final_vote_qualified_roots.push_back (i->first); + } + + for (auto & final_vote_qualified_root : final_vote_qualified_roots) + { + auto status (store.del (transaction_a, tables::final_votes, nano::db_val (final_vote_qualified_root))); + release_assert_success (store, status); + } + } + + size_t count (nano::transaction const & transaction_a) const override + { + return store.count (transaction_a, tables::final_votes); + } + + void clear (nano::write_transaction const & transaction_a, nano::root const & root_a) override + { + del (transaction_a, root_a); + } + + void clear (nano::write_transaction const & transaction_a) override + { + store.drop (transaction_a, nano::tables::final_votes); + } + + nano::store_iterator begin (nano::transaction const & transaction_a, nano::qualified_root const & root_a) const override + { + return store.template make_iterator (transaction_a, tables::final_votes, nano::db_val (root_a)); + } + + nano::store_iterator begin (nano::transaction const & transaction_a) const override + { + return store.template make_iterator (transaction_a, tables::final_votes); + } + + nano::store_iterator end () const override + { + return nano::store_iterator (nullptr); + } + + void for_each_par (std::function, nano::store_iterator)> const & action_a) const override + { + parallel_traversal ( + [&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) { + auto transaction (this->store.tx_begin_read ()); + action_a (transaction, this->begin (transaction, start), !is_last ? this->begin (transaction, end) : this->end ()); + }); + } +}; + +} diff --git a/nano/secure/store/frontier_store_partial.hpp b/nano/secure/store/frontier_store_partial.hpp new file mode 100644 index 0000000000..78d44a3184 --- /dev/null +++ b/nano/secure/store/frontier_store_partial.hpp @@ -0,0 +1,82 @@ +#pragma once + +#include + +namespace +{ +template +void parallel_traversal (std::function const & action); +} + +namespace nano +{ +template +class store_partial; + +template +void release_assert_success (store_partial const & store, int const status); + +template +class frontier_store_partial : public frontier_store +{ +private: + nano::store_partial & store; + + friend void release_assert_success (store_partial const &, int const); + +public: + explicit frontier_store_partial (nano::store_partial & store_a) : + store (store_a){}; + + void put (nano::write_transaction const & transaction_a, nano::block_hash const & block_a, nano::account const & account_a) override + { + nano::db_val account (account_a); + auto status (store.put (transaction_a, tables::frontiers, block_a, account)); + release_assert_success (store, status); + } + + nano::account get (nano::transaction const & transaction_a, nano::block_hash const & block_a) const override + { + nano::db_val value; + auto status (store.get (transaction_a, tables::frontiers, nano::db_val (block_a), value)); + release_assert (store.success (status) || store.not_found (status)); + nano::account result{}; + if (store.success (status)) + { + result = static_cast (value); + } + return result; + } + + void del (nano::write_transaction const & transaction_a, nano::block_hash const & block_a) override + { + auto status (store.del (transaction_a, tables::frontiers, block_a)); + release_assert_success (store, status); + } + + nano::store_iterator begin (nano::transaction const & transaction_a) const override + { + return store.template make_iterator (transaction_a, tables::frontiers); + } + + nano::store_iterator begin (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override + { + return store.template make_iterator (transaction_a, tables::frontiers, nano::db_val (hash_a)); + } + + nano::store_iterator end () const override + { + return nano::store_iterator (nullptr); + } + + void for_each_par (std::function, nano::store_iterator)> const & action_a) const override + { + parallel_traversal ( + [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { + auto transaction (this->store.tx_begin_read ()); + action_a (transaction, this->begin (transaction, start), !is_last ? this->begin (transaction, end) : this->end ()); + }); + } +}; + +} diff --git a/nano/secure/store/online_weight_partial.hpp b/nano/secure/store/online_weight_partial.hpp new file mode 100644 index 0000000000..0e1bbefd95 --- /dev/null +++ b/nano/secure/store/online_weight_partial.hpp @@ -0,0 +1,65 @@ +#pragma once + +#include + +namespace nano +{ +template +class store_partial; + +template +void release_assert_success (store_partial const &, int const); + +template +class online_weight_store_partial : public online_weight_store +{ +private: + nano::store_partial & store; + + friend void release_assert_success (store_partial const &, int const); + +public: + explicit online_weight_store_partial (nano::store_partial & store_a) : + store (store_a){}; + + void put (nano::write_transaction const & transaction_a, uint64_t time_a, nano::amount const & amount_a) override + { + nano::db_val value (amount_a); + auto status (store.put (transaction_a, tables::online_weight, time_a, value)); + release_assert_success (store, status); + } + + void del (nano::write_transaction const & transaction_a, uint64_t time_a) override + { + auto status (store.del (transaction_a, tables::online_weight, time_a)); + release_assert_success (store, status); + } + + nano::store_iterator begin (nano::transaction const & transaction_a) const override + { + return store.template make_iterator (transaction_a, tables::online_weight); + } + + nano::store_iterator rbegin (nano::transaction const & transaction_a) const override + { + return store.template make_iterator (transaction_a, tables::online_weight, false); + } + + nano::store_iterator end () const override + { + return nano::store_iterator (nullptr); + } + + size_t count (nano::transaction const & transaction_a) const override + { + return store.count (transaction_a, tables::online_weight); + } + + void clear (nano::write_transaction const & transaction_a) override + { + auto status (store.drop (transaction_a, tables::online_weight)); + release_assert_success (store, status); + } +}; + +} diff --git a/nano/secure/store/peer_store_partial.hpp b/nano/secure/store/peer_store_partial.hpp new file mode 100644 index 0000000000..913e17a632 --- /dev/null +++ b/nano/secure/store/peer_store_partial.hpp @@ -0,0 +1,70 @@ +#pragma once + +#include + +namespace +{ +template +void parallel_traversal (std::function const & action); +} + +namespace nano +{ +template +class store_partial; + +template +void release_assert_success (store_partial const &, int const); + +template +class peer_store_partial : public peer_store +{ +private: + nano::store_partial & store; + + friend void release_assert_success (store_partial const &, int const); + +public: + explicit peer_store_partial (nano::store_partial & store_a) : + store (store_a){}; + + void put (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) override + { + auto status = store.put_key (transaction_a, tables::peers, endpoint_a); + release_assert_success (store, status); + } + + void del (nano::write_transaction const & transaction_a, nano::endpoint_key const & endpoint_a) override + { + auto status (store.del (transaction_a, tables::peers, endpoint_a)); + release_assert_success (store, status); + } + + bool exists (nano::transaction const & transaction_a, nano::endpoint_key const & endpoint_a) const override + { + return store.exists (transaction_a, tables::peers, nano::db_val (endpoint_a)); + } + + size_t count (nano::transaction const & transaction_a) const override + { + return store.count (transaction_a, tables::peers); + } + + void clear (nano::write_transaction const & transaction_a) override + { + auto status = store.drop (transaction_a, tables::peers); + release_assert_success (store, status); + } + + nano::store_iterator begin (nano::transaction const & transaction_a) const override + { + return store.template make_iterator (transaction_a, tables::peers); + } + + nano::store_iterator end () const override + { + return nano::store_iterator (nullptr); + } +}; + +} diff --git a/nano/secure/store/pending_store_partial.hpp b/nano/secure/store/pending_store_partial.hpp new file mode 100644 index 0000000000..25d6ba54fa --- /dev/null +++ b/nano/secure/store/pending_store_partial.hpp @@ -0,0 +1,100 @@ +#pragma once + +#include + +namespace +{ +template +void parallel_traversal (std::function const & action); +} + +namespace nano +{ +template +class store_partial; + +template +void release_assert_success (store_partial const &, int const); + +template +class pending_store_partial : public pending_store +{ +private: + nano::store_partial & store; + + friend void release_assert_success (store_partial const &, int const); + +public: + explicit pending_store_partial (nano::store_partial & store_a) : + store (store_a){}; + + void put (nano::write_transaction const & transaction_a, nano::pending_key const & key_a, nano::pending_info const & pending_info_a) override + { + nano::db_val pending (pending_info_a); + auto status = store.put (transaction_a, tables::pending, key_a, pending); + release_assert_success (store, status); + } + + void del (nano::write_transaction const & transaction_a, nano::pending_key const & key_a) override + { + auto status = store.del (transaction_a, tables::pending, key_a); + release_assert_success (store, status); + } + + bool get (nano::transaction const & transaction_a, nano::pending_key const & key_a, nano::pending_info & pending_a) override + { + nano::db_val value; + nano::db_val key (key_a); + auto status1 = store.get (transaction_a, tables::pending, key, value); + release_assert (store.success (status1) || store.not_found (status1)); + bool result (true); + if (store.success (status1)) + { + nano::bufferstream stream (reinterpret_cast (value.data ()), value.size ()); + result = pending_a.deserialize (stream); + } + return result; + } + + bool exists (nano::transaction const & transaction_a, nano::pending_key const & key_a) override + { + auto iterator (begin (transaction_a, key_a)); + return iterator != end () && nano::pending_key (iterator->first) == key_a; + } + + bool any (nano::transaction const & transaction_a, nano::account const & account_a) override + { + auto iterator (begin (transaction_a, nano::pending_key (account_a, 0))); + return iterator != end () && nano::pending_key (iterator->first).account == account_a; + } + + nano::store_iterator begin (nano::transaction const & transaction_a, nano::pending_key const & key_a) const override + { + return store.template make_iterator (transaction_a, tables::pending, nano::db_val (key_a)); + } + + nano::store_iterator begin (nano::transaction const & transaction_a) const override + { + return store.template make_iterator (transaction_a, tables::pending); + } + + nano::store_iterator end () const override + { + return nano::store_iterator (nullptr); + } + + void for_each_par (std::function, nano::store_iterator)> const & action_a) const override + { + parallel_traversal ( + [&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) { + nano::uint512_union union_start (start); + nano::uint512_union union_end (end); + nano::pending_key key_start (union_start.uint256s[0].number (), union_start.uint256s[1].number ()); + nano::pending_key key_end (union_end.uint256s[0].number (), union_end.uint256s[1].number ()); + auto transaction (this->store.tx_begin_read ()); + action_a (transaction, this->begin (transaction, key_start), !is_last ? this->begin (transaction, key_end) : this->end ()); + }); + } +}; + +} diff --git a/nano/secure/store/pruned_store_partial.hpp b/nano/secure/store/pruned_store_partial.hpp new file mode 100644 index 0000000000..93b9e1a0df --- /dev/null +++ b/nano/secure/store/pruned_store_partial.hpp @@ -0,0 +1,97 @@ +#pragma once + +#include + +namespace +{ +template +void parallel_traversal (std::function const & action); +} + +namespace nano +{ +template +class store_partial; + +template +void release_assert_success (store_partial const &, int const); + +template +class pruned_store_partial : public pruned_store +{ +private: + nano::store_partial & store; + + friend void release_assert_success (store_partial const &, int const); + +public: + explicit pruned_store_partial (nano::store_partial & store_a) : + store (store_a){}; + + void put (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a) override + { + auto status = store.put_key (transaction_a, tables::pruned, hash_a); + release_assert_success (store, status); + } + + void del (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a) override + { + auto status = store.del (transaction_a, tables::pruned, hash_a); + release_assert_success (store, status); + } + + bool exists (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override + { + return store.exists (transaction_a, tables::pruned, nano::db_val (hash_a)); + } + + nano::block_hash random (nano::transaction const & transaction_a) override + { + nano::block_hash random_hash; + nano::random_pool::generate_block (random_hash.bytes.data (), random_hash.bytes.size ()); + auto existing = store.template make_iterator> (transaction_a, tables::pruned, nano::db_val (random_hash)); + auto end (nano::store_iterator> (nullptr)); + if (existing == end) + { + existing = store.template make_iterator> (transaction_a, tables::pruned); + } + return existing != end ? existing->first : 0; + } + + size_t count (nano::transaction const & transaction_a) const override + { + return store.count (transaction_a, tables::pruned); + } + + void clear (nano::write_transaction const & transaction_a) override + { + auto status = store.drop (transaction_a, tables::pruned); + release_assert_success (store, status); + } + + nano::store_iterator begin (nano::transaction const & transaction_a, nano::block_hash const & hash_a) const override + { + return store.template make_iterator (transaction_a, tables::pruned, nano::db_val (hash_a)); + } + + nano::store_iterator begin (nano::transaction const & transaction_a) const override + { + return store.template make_iterator (transaction_a, tables::pruned); + } + + nano::store_iterator end () const override + { + return nano::store_iterator (nullptr); + } + + void for_each_par (std::function, nano::store_iterator)> const & action_a) const override + { + parallel_traversal ( + [&action_a, this] (nano::uint256_t const & start, nano::uint256_t const & end, bool const is_last) { + auto transaction (this->store.tx_begin_read ()); + action_a (transaction, this->begin (transaction, start), !is_last ? this->begin (transaction, end) : this->end ()); + }); + } +}; + +} diff --git a/nano/secure/store/unchecked_store_partial.hpp b/nano/secure/store/unchecked_store_partial.hpp new file mode 100644 index 0000000000..845135172d --- /dev/null +++ b/nano/secure/store/unchecked_store_partial.hpp @@ -0,0 +1,97 @@ +#pragma once + +#include + +namespace +{ +template +void parallel_traversal (std::function const & action); +} + +namespace nano +{ +template +class store_partial; + +template +void release_assert_success (store_partial const &, int const); + +template +class unchecked_store_partial : public unchecked_store +{ +private: + nano::store_partial & store; + + friend void release_assert_success (store_partial const &, int const); + +public: + unchecked_store_partial (nano::store_partial & store_a) : + store (store_a){}; + + void clear (nano::write_transaction const & transaction_a) override + { + auto status = store.drop (transaction_a, tables::unchecked); + release_assert_success (store, status); + } + + void put (nano::write_transaction const & transaction_a, nano::unchecked_key const & key_a, nano::unchecked_info const & info_a) override + { + nano::db_val info (info_a); + auto status (store.put (transaction_a, tables::unchecked, key_a, info)); + release_assert_success (store, status); + } + + void put (nano::write_transaction const & transaction_a, nano::block_hash const & hash_a, std::shared_ptr const & block_a) override + { + nano::unchecked_key key (hash_a, block_a->hash ()); + nano::unchecked_info info (block_a, block_a->account (), nano::seconds_since_epoch (), nano::signature_verification::unknown); + put (transaction_a, key, info); + } + + bool exists (nano::transaction const & transaction_a, nano::unchecked_key const & unchecked_key_a) override + { + nano::db_val value; + auto status (store.get (transaction_a, tables::unchecked, nano::db_val (unchecked_key_a), value)); + release_assert (store.success (status) || store.not_found (status)); + return (store.success (status)); + } + + void del (nano::write_transaction const & transaction_a, nano::unchecked_key const & key_a) override + { + auto status (store.del (transaction_a, tables::unchecked, key_a)); + release_assert_success (store, status); + } + + nano::store_iterator end () const override + { + return nano::store_iterator (nullptr); + } + + nano::store_iterator begin (nano::transaction const & transaction_a) const override + { + return store.template make_iterator (transaction_a, tables::unchecked); + } + + nano::store_iterator begin (nano::transaction const & transaction_a, nano::unchecked_key const & key_a) const override + { + return store.template make_iterator (transaction_a, tables::unchecked, nano::db_val (key_a)); + } + + size_t count (nano::transaction const & transaction_a) override + { + return store.count (transaction_a, tables::unchecked); + } + + void for_each_par (std::function, nano::store_iterator)> const & action_a) const override + { + parallel_traversal ( + [&action_a, this] (nano::uint512_t const & start, nano::uint512_t const & end, bool const is_last) { + nano::unchecked_key key_start (start); + nano::unchecked_key key_end (end); + auto transaction (this->store.tx_begin_read ()); + action_a (transaction, this->begin (transaction, key_start), !is_last ? this->begin (transaction, key_end) : this->end ()); + }); + } +}; + +} diff --git a/nano/secure/store/version_store_partial.hpp b/nano/secure/store/version_store_partial.hpp new file mode 100644 index 0000000000..9966c20da0 --- /dev/null +++ b/nano/secure/store/version_store_partial.hpp @@ -0,0 +1,47 @@ +#pragma once + +#include + +namespace nano +{ +template +class store_partial; + +template +void release_assert_success (store_partial const &, int const); + +template +class version_store_partial : public version_store +{ +protected: + nano::store_partial & store; + +public: + explicit version_store_partial (nano::store_partial & store_a) : + store (store_a){}; + + void put (nano::write_transaction const & transaction_a, int version_a) override + { + nano::uint256_union version_key (1); + nano::uint256_union version_value (version_a); + auto status (store.put (transaction_a, tables::meta, nano::db_val (version_key), nano::db_val (version_value))); + release_assert_success (store, status); + } + + int get (nano::transaction const & transaction_a) const override + { + nano::uint256_union version_key (1); + nano::db_val data; + auto status = store.get (transaction_a, tables::meta, nano::db_val (version_key), data); + int result (store.minimum_version); + if (store.success (status)) + { + nano::uint256_union version_value (data); + debug_assert (version_value.qwords[2] == 0 && version_value.qwords[1] == 0 && version_value.qwords[0] == 0); + result = version_value.number ().convert_to (); + } + return result; + } +}; + +} diff --git a/nano/secure/store_partial.hpp b/nano/secure/store_partial.hpp new file mode 100644 index 0000000000..31103cee92 --- /dev/null +++ b/nano/secure/store_partial.hpp @@ -0,0 +1,219 @@ +#pragma once + +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include + +#include + +#include + +class store_partial; +namespace +{ +template +void parallel_traversal (std::function const & action); +} + +namespace nano +{ +template +class block_predecessor_set; + +template +void release_assert_success (store_partial const & store, int const status) +{ + if (!store.success (status)) + { + release_assert (false, store.error_string (status)); + } +} + +template +class account_store_partial; + +template +class unchecked_store_partial; + +template +class block_store_partial; + +/** This base class implements the store interface functions which have DB agnostic functionality. It also maps all the store classes. */ +template +class store_partial : public store +{ + friend void release_assert_success (store_partial const &, int const); + friend class nano::block_store_partial; + friend class nano::frontier_store_partial; + friend class nano::account_store_partial; + friend class nano::pending_store_partial; + friend class nano::unchecked_store_partial; + friend class nano::online_weight_store_partial; + friend class nano::pruned_store_partial; + friend class nano::peer_store_partial; + friend class nano::confirmation_height_store_partial; + friend class nano::final_vote_store_partial; + friend class nano::version_store_partial; + +public: + // clang-format off + store_partial ( + nano::ledger_constants & constants, + nano::block_store_partial & block_store_partial_a, + nano::frontier_store_partial & frontier_store_partial_a, + nano::account_store_partial & account_store_partial_a, + nano::pending_store_partial & pending_store_partial_a, + nano::unchecked_store_partial & unchecked_store_partial_a, + nano::online_weight_store_partial & online_weight_store_partial_a, + nano::pruned_store_partial & pruned_store_partial_a, + nano::peer_store_partial & peer_store_partial_a, + nano::confirmation_height_store_partial & confirmation_height_store_partial_a, + nano::final_vote_store_partial & final_vote_store_partial_a, + nano::version_store_partial & version_store_partial_a) : + constants{ constants }, + store{ + block_store_partial_a, + frontier_store_partial_a, + account_store_partial_a, + pending_store_partial_a, + unchecked_store_partial_a, + online_weight_store_partial_a, + pruned_store_partial_a, + peer_store_partial_a, + confirmation_height_store_partial_a, + final_vote_store_partial_a, + version_store_partial_a + } + {} + // clang-format on + + /** + * If using a different store version than the latest then you may need + * to modify some of the objects in the store to be appropriate for the version before an upgrade. + */ + void initialize (nano::write_transaction const & transaction_a, nano::ledger_cache & ledger_cache_a) override + { + debug_assert (constants.genesis->has_sideband ()); + debug_assert (account.begin (transaction_a) == account.end ()); + auto hash_l (constants.genesis->hash ()); + block.put (transaction_a, hash_l, *constants.genesis); + ++ledger_cache_a.block_count; + confirmation_height.put (transaction_a, constants.genesis->account (), nano::confirmation_height_info{ 1, constants.genesis->hash () }); + ++ledger_cache_a.cemented_count; + ledger_cache_a.final_votes_confirmation_canary = (constants.final_votes_canary_account == constants.genesis->account () && 1 >= constants.final_votes_canary_height); + account.put (transaction_a, constants.genesis->account (), { hash_l, constants.genesis->account (), constants.genesis->hash (), std::numeric_limits::max (), nano::seconds_since_epoch (), 1, nano::epoch::epoch_0 }); + ++ledger_cache_a.account_count; + ledger_cache_a.rep_weights.representation_put (constants.genesis->account (), std::numeric_limits::max ()); + frontier.put (transaction_a, hash_l, constants.genesis->account ()); + } + + bool root_exists (nano::transaction const & transaction_a, nano::root const & root_a) override + { + return block.exists (transaction_a, root_a.as_block_hash ()) || account.exists (transaction_a, root_a.as_account ()); + } + + bool exists (nano::transaction const & transaction_a, tables table_a, nano::db_val const & key_a) const + { + return static_cast (*this).exists (transaction_a, table_a, key_a); + } + + int const minimum_version{ 14 }; + +protected: + nano::ledger_constants & constants; + int const version_number{ 21 }; + + template + nano::store_iterator make_iterator (nano::transaction const & transaction_a, tables table_a, bool const direction_asc = true) const + { + return static_cast (*this).template make_iterator (transaction_a, table_a, direction_asc); + } + + template + nano::store_iterator make_iterator (nano::transaction const & transaction_a, tables table_a, nano::db_val const & key) const + { + return static_cast (*this).template make_iterator (transaction_a, table_a, key); + } + + uint64_t count (nano::transaction const & transaction_a, std::initializer_list dbs_a) const + { + uint64_t total_count = 0; + for (auto db : dbs_a) + { + total_count += count (transaction_a, db); + } + return total_count; + } + + int get (nano::transaction const & transaction_a, tables table_a, nano::db_val const & key_a, nano::db_val & value_a) const + { + return static_cast (*this).get (transaction_a, table_a, key_a, value_a); + } + + int put (nano::write_transaction const & transaction_a, tables table_a, nano::db_val const & key_a, nano::db_val const & value_a) + { + return static_cast (*this).put (transaction_a, table_a, key_a, value_a); + } + + // Put only key without value + int put_key (nano::write_transaction const & transaction_a, tables table_a, nano::db_val const & key_a) + { + return this->put (transaction_a, table_a, key_a, nano::db_val{ nullptr }); + } + + int del (nano::write_transaction const & transaction_a, tables table_a, nano::db_val const & key_a) + { + return static_cast (*this).del (transaction_a, table_a, key_a); + } + + virtual uint64_t count (nano::transaction const & transaction_a, tables table_a) const = 0; + virtual int drop (nano::write_transaction const & transaction_a, tables table_a) = 0; + virtual bool not_found (int status) const = 0; + virtual bool success (int status) const = 0; + virtual int status_code_not_found () const = 0; + virtual std::string error_string (int status) const = 0; +}; +} + +namespace +{ +template +void parallel_traversal (std::function const & action) +{ + // Between 10 and 40 threads, scales well even in low power systems as long as actions are I/O bound + unsigned const thread_count = std::max (10u, std::min (40u, 10 * std::thread::hardware_concurrency ())); + T const value_max{ std::numeric_limits::max () }; + T const split = value_max / thread_count; + std::vector threads; + threads.reserve (thread_count); + for (unsigned thread (0); thread < thread_count; ++thread) + { + T const start = thread * split; + T const end = (thread + 1) * split; + bool const is_last = thread == thread_count - 1; + + threads.emplace_back ([&action, start, end, is_last] { + nano::thread_role::set (nano::thread_role::name::db_parallel_traversal); + action (start, end, is_last); + }); + } + for (auto & thread : threads) + { + thread.join (); + } +} +} diff --git a/nano/secure/utility.cpp b/nano/secure/utility.cpp index f1858a3f0a..32cd884c8f 100644 --- a/nano/secure/utility.cpp +++ b/nano/secure/utility.cpp @@ -6,59 +6,33 @@ static std::vector all_unique_paths; -boost::filesystem::path nano::working_path (bool legacy) +boost::filesystem::path nano::working_path (nano::networks network) { - static nano::network_constants network_constants; auto result (nano::app_path ()); - switch (network_constants.network ()) + switch (network) { - case nano::nano_networks::nano_dev_network: - if (!legacy) - { - result /= "BananoDev"; - } - else - { - result /= "BananoDev"; - } + case nano::networks::invalid: + release_assert (false); break; - case nano::nano_networks::nano_beta_network: - if (!legacy) - { - result /= "BananoBeta"; - } - else - { - result /= "BananoBeta"; - } + case nano::networks::nano_dev_network: + result /= "BananoDev"; break; - case nano::nano_networks::nano_live_network: - if (!legacy) - { - result /= "BananoData"; - } - else - { - result /= "Banano"; - } + case nano::networks::nano_beta_network: + result /= "BananoBeta"; break; - case nano::nano_networks::nano_test_network: - if (!legacy) - { - result /= "BananoTest"; - } - else - { - result /= "BananoTest"; - } + case nano::networks::nano_live_network: + result /= "BananoData"; + break; + case nano::networks::nano_test_network: + result /= "BananoTest"; break; } return result; } -boost::filesystem::path nano::unique_path () +boost::filesystem::path nano::unique_path (nano::networks network) { - auto result (working_path () / boost::filesystem::unique_path ()); + auto result (working_path (network) / boost::filesystem::unique_path ()); all_unique_paths.push_back (result); return result; } diff --git a/nano/secure/utility.hpp b/nano/secure/utility.hpp index 0d090e5d81..ae678294f1 100644 --- a/nano/secure/utility.hpp +++ b/nano/secure/utility.hpp @@ -1,16 +1,16 @@ #pragma once -#include +#include #include namespace nano { // OS-specific way of finding a path to a home directory. -boost::filesystem::path working_path (bool = false); +boost::filesystem::path working_path (nano::networks network = nano::network_constants::active_network); // Get a unique path within the home directory, used for testing. // Any directories created at this location will be removed when a test finishes. -boost::filesystem::path unique_path (); +boost::filesystem::path unique_path (nano::networks network = nano::network_constants::active_network); // Remove all unique tmp directories created by the process void remove_temporary_directories (); // Generic signal handler declarations diff --git a/nano/secure/versioning.cpp b/nano/secure/versioning.cpp index 11d3a6b631..1ab31d5819 100644 --- a/nano/secure/versioning.cpp +++ b/nano/secure/versioning.cpp @@ -51,13 +51,13 @@ nano::account_info_v14::account_info_v14 (nano::block_hash const & head_a, nano: size_t nano::account_info_v14::db_size () const { - debug_assert (reinterpret_cast (this) == reinterpret_cast (&head)); - debug_assert (reinterpret_cast (&head) + sizeof (head) == reinterpret_cast (&rep_block)); - debug_assert (reinterpret_cast (&rep_block) + sizeof (rep_block) == reinterpret_cast (&open_block)); - debug_assert (reinterpret_cast (&open_block) + sizeof (open_block) == reinterpret_cast (&balance)); - debug_assert (reinterpret_cast (&balance) + sizeof (balance) == reinterpret_cast (&modified)); - debug_assert (reinterpret_cast (&modified) + sizeof (modified) == reinterpret_cast (&block_count)); - debug_assert (reinterpret_cast (&block_count) + sizeof (block_count) == reinterpret_cast (&confirmation_height)); + debug_assert (reinterpret_cast (this) == reinterpret_cast (&head)); + debug_assert (reinterpret_cast (&head) + sizeof (head) == reinterpret_cast (&rep_block)); + debug_assert (reinterpret_cast (&rep_block) + sizeof (rep_block) == reinterpret_cast (&open_block)); + debug_assert (reinterpret_cast (&open_block) + sizeof (open_block) == reinterpret_cast (&balance)); + debug_assert (reinterpret_cast (&balance) + sizeof (balance) == reinterpret_cast (&modified)); + debug_assert (reinterpret_cast (&modified) + sizeof (modified) == reinterpret_cast (&block_count)); + debug_assert (reinterpret_cast (&block_count) + sizeof (block_count) == reinterpret_cast (&confirmation_height)); return sizeof (head) + sizeof (rep_block) + sizeof (open_block) + sizeof (balance) + sizeof (modified) + sizeof (block_count) + sizeof (confirmation_height); } diff --git a/nano/secure/versioning.hpp b/nano/secure/versioning.hpp index 953ab410b9..429de22d97 100644 --- a/nano/secure/versioning.hpp +++ b/nano/secure/versioning.hpp @@ -15,7 +15,7 @@ class pending_info_v14 final size_t db_size () const; bool deserialize (nano::stream &); bool operator== (nano::pending_info_v14 const &) const; - nano::account source{ 0 }; + nano::account source{}; nano::amount amount{ 0 }; nano::epoch epoch{ nano::epoch::epoch_0 }; }; @@ -44,7 +44,7 @@ class block_sideband_v14 final static size_t size (nano::block_type); nano::block_type type{ nano::block_type::invalid }; nano::block_hash successor{ 0 }; - nano::account account{ 0 }; + nano::account account{}; nano::amount balance{ 0 }; uint64_t height{ 0 }; uint64_t timestamp{ 0 }; @@ -65,7 +65,7 @@ class block_sideband_v18 final bool deserialize (nano::stream &, nano::block_type); static size_t size (nano::block_type); nano::block_hash successor{ 0 }; - nano::account account{ 0 }; + nano::account account{}; nano::amount balance{ 0 }; uint64_t height{ 0 }; uint64_t timestamp{ 0 }; diff --git a/nano/slow_test/node.cpp b/nano/slow_test/node.cpp index 917401ac0b..030c485efa 100644 --- a/nano/slow_test/node.cpp +++ b/nano/slow_test/node.cpp @@ -1,9 +1,9 @@ #include #include #include -#include #include #include +#include #include #include @@ -22,11 +22,11 @@ TEST (system, generate_mass_activity) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.enable_voting = false; // Prevent blocks cementing auto node = system.add_node (node_config); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); uint32_t count (20); system.generate_mass_activity (count, *system.nodes[0]); auto transaction (system.nodes[0]->store.tx_begin_read ()); - for (auto i (system.nodes[0]->store.accounts_begin (transaction)), n (system.nodes[0]->store.accounts_end ()); i != n; ++i) + for (auto i (system.nodes[0]->store.account.begin (transaction)), n (system.nodes[0]->store.account.end ()); i != n; ++i) { } } @@ -38,11 +38,11 @@ TEST (system, generate_mass_activity_long) node_config.enable_voting = false; // Prevent blocks cementing auto node = system.add_node (node_config); nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); uint32_t count (1000000000); system.generate_mass_activity (count, *system.nodes[0]); auto transaction (system.nodes[0]->store.tx_begin_read ()); - for (auto i (system.nodes[0]->store.accounts_begin (transaction)), n (system.nodes[0]->store.accounts_end ()); i != n; ++i) + for (auto i (system.nodes[0]->store.account.begin (transaction)), n (system.nodes[0]->store.account.end ()); i != n; ++i) { } system.stop (); @@ -58,22 +58,22 @@ TEST (system, receive_while_synchronizing) node_config.enable_voting = false; // Prevent blocks cementing auto node = system.add_node (node_config); nano::thread_runner runner (system.io_ctx, system.nodes[0]->config.io_threads); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); uint32_t count (1000); system.generate_mass_activity (count, *system.nodes[0]); nano::keypair key; auto node1 (std::make_shared (system.io_ctx, nano::get_available_port (), nano::unique_path (), system.logging, system.work)); ASSERT_FALSE (node1->init_error ()); auto wallet (node1->wallets.create (1)); - wallet->insert_adhoc (nano::dev_genesis_key.prv); // For voting + wallet->insert_adhoc (nano::dev::genesis_key.prv); // For voting ASSERT_EQ (key.pub, wallet->insert_adhoc (key.prv)); node1->start (); system.nodes.push_back (node1); ASSERT_NE (nullptr, nano::establish_tcp (system, *node1, node->network.endpoint ())); node1->workers.add_timed_task (std::chrono::steady_clock::now () + std::chrono::milliseconds (200), ([&system, &key] () { - auto hash (system.wallet (0)->send_sync (nano::dev_genesis_key.pub, key.pub, system.nodes[0]->config.receive_minimum.number ())); + auto hash (system.wallet (0)->send_sync (nano::dev::genesis_key.pub, key.pub, system.nodes[0]->config.receive_minimum.number ())); auto transaction (system.nodes[0]->store.tx_begin_read ()); - auto block (system.nodes[0]->store.block_get (transaction, hash)); + auto block (system.nodes[0]->store.block.get (transaction, hash)); std::string block_text; block->serialize_json (block_text); })); @@ -91,26 +91,25 @@ TEST (system, receive_while_synchronizing) TEST (ledger, deep_account_compute) { nano::logger_mt logger; - auto store = nano::make_store (logger, nano::unique_path ()); + auto store = nano::make_store (logger, nano::unique_path (), nano::dev::constants); ASSERT_FALSE (store->init_error ()); nano::stat stats; - nano::ledger ledger (*store, stats); - nano::genesis genesis; + nano::ledger ledger (*store, stats, nano::dev::constants); auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); - nano::work_pool pool (std::numeric_limits::max ()); + store->initialize (transaction, ledger.cache); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; nano::keypair key; - auto balance (nano::genesis_amount - 1); - nano::send_block send (genesis.hash (), key.pub, balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (genesis.hash ())); + auto balance (nano::dev::constants.genesis_amount - 1); + nano::send_block send (nano::dev::genesis->hash (), key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (nano::dev::genesis->hash ())); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); - nano::open_block open (send.hash (), nano::dev_genesis_key.pub, key.pub, key.prv, key.pub, *pool.generate (key.pub)); + nano::open_block open (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *pool.generate (key.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, open).code); auto sprevious (send.hash ()); auto rprevious (open.hash ()); for (auto i (0), n (100000); i != n; ++i) { balance -= 1; - nano::send_block send (sprevious, key.pub, balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (sprevious)); + nano::send_block send (sprevious, key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (sprevious)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); sprevious = send.hash (); nano::receive_block receive (rprevious, send.hash (), key.prv, key.pub, *pool.generate (rprevious)); @@ -125,6 +124,12 @@ TEST (ledger, deep_account_compute) } } +/* + * This test case creates a node and a wallet primed with the genesis account credentials. + * Then it spawns 'num_of_threads' threads, each doing 'num_of_sends' async sends + * of 1000 raw each time. The test is considered a success, if the balance of the genesis account + * reduces by 'num_of_threads * num_of_sends * 1000'. + */ TEST (wallet, multithreaded_send_async) { std::vector threads; @@ -132,21 +137,23 @@ TEST (wallet, multithreaded_send_async) nano::system system (1); nano::keypair key; auto wallet_l (system.wallet (0)); - wallet_l->insert_adhoc (nano::dev_genesis_key.prv); + wallet_l->insert_adhoc (nano::dev::genesis_key.prv); wallet_l->insert_adhoc (key.prv); - for (auto i (0); i < 20; ++i) + int num_of_threads = 20; + int num_of_sends = 1000; + for (auto i (0); i < num_of_threads; ++i) { - threads.push_back (boost::thread ([wallet_l, &key] () { - for (auto i (0); i < 1000; ++i) + threads.push_back (boost::thread ([wallet_l, &key, num_of_threads, num_of_sends] () { + for (auto i (0); i < num_of_sends; ++i) { - wallet_l->send_async (nano::dev_genesis_key.pub, key.pub, 1000, [] (std::shared_ptr const & block_a) { + wallet_l->send_async (nano::dev::genesis_key.pub, key.pub, 1000, [] (std::shared_ptr const & block_a) { ASSERT_FALSE (block_a == nullptr); ASSERT_FALSE (block_a->hash ().is_zero ()); }); } })); } - ASSERT_TIMELY (1000s, system.nodes[0]->balance (nano::dev_genesis_key.pub) == (nano::genesis_amount - 20 * 1000 * 1000)); + ASSERT_TIMELY (1000s, system.nodes[0]->balance (nano::dev::genesis_key.pub) == (nano::dev::constants.genesis_amount - num_of_threads * num_of_sends * 1000)); } for (auto i (threads.begin ()), n (threads.end ()); i != n; ++i) { @@ -168,8 +175,8 @@ TEST (store, load) { nano::account account; nano::random_pool::generate_block (account.bytes.data (), account.bytes.size ()); - system.nodes[0]->store.confirmation_height_put (transaction, account, { 0, nano::block_hash (0) }); - system.nodes[0]->store.account_put (transaction, account, nano::account_info ()); + system.nodes[0]->store.confirmation_height.put (transaction, account, { 0, nano::block_hash (0) }); + system.nodes[0]->store.account.put (transaction, account, nano::account_info ()); } } })); @@ -186,15 +193,15 @@ TEST (node, fork_storm) nano::node_flags flags; flags.disable_max_peers_per_ip = true; nano::system system (64, nano::transport::transport_type::tcp, flags); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - auto previous (system.nodes[0]->latest (nano::dev_genesis_key.pub)); - auto balance (system.nodes[0]->balance (nano::dev_genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + auto previous (system.nodes[0]->latest (nano::dev::genesis_key.pub)); + auto balance (system.nodes[0]->balance (nano::dev::genesis_key.pub)); ASSERT_FALSE (previous.is_zero ()); for (auto j (0); j != system.nodes.size (); ++j) { balance -= 1; nano::keypair key; - nano::send_block send (previous, key.pub, balance, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0); + nano::send_block send (previous, key.pub, balance, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0); system.nodes[j]->work_generate_blocking (send); previous = send.hash (); for (auto i (0); i != system.nodes.size (); ++i) @@ -393,25 +400,25 @@ TEST (store, unchecked_load) { nano::system system (1); auto & node (*system.nodes[0]); - auto block (std::make_shared (0, 0, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto block (std::make_shared (0, 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); constexpr auto num_unchecked = 1000000; - for (auto i (0); i < 1000000; ++i) + for (auto i (0); i < num_unchecked; ++i) { auto transaction (node.store.tx_begin_write ()); - node.store.unchecked_put (transaction, i, block); + node.store.unchecked.put (transaction, i, block); } auto transaction (node.store.tx_begin_read ()); - ASSERT_EQ (num_unchecked, node.store.unchecked_count (transaction)); + ASSERT_EQ (num_unchecked, node.store.unchecked.count (transaction)); } TEST (store, vote_load) { nano::system system (1); auto & node (*system.nodes[0]); - auto block (std::make_shared (0, 0, 0, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, 0)); + auto block (std::make_shared (0, 0, 0, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, 0)); for (auto i (0); i < 1000000; ++i) { - auto vote (std::make_shared (nano::dev_genesis_key.pub, nano::dev_genesis_key.prv, i, block)); + auto vote (std::make_shared (nano::dev::genesis_key.pub, nano::dev::genesis_key.prv, i, 0, block)); node.vote_processor.vote (vote, std::make_shared (node)); } } @@ -421,11 +428,11 @@ TEST (store, pruned_load) nano::logger_mt logger; auto path (nano::unique_path ()); constexpr auto num_pruned = 2000000; - auto const expected_result = nano::using_rocksdb_in_tests () ? num_pruned : num_pruned / 2; + auto const expected_result = nano::rocksdb_config::using_rocksdb_in_tests () ? num_pruned : num_pruned / 2; constexpr auto batch_size = 20; boost::unordered_set hashes; { - auto store = nano::make_store (logger, path); + auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_FALSE (store->init_error ()); for (auto i (0); i < num_pruned / batch_size; ++i) { @@ -435,29 +442,29 @@ TEST (store, pruned_load) { nano::block_hash random_hash; nano::random_pool::generate_block (random_hash.bytes.data (), random_hash.bytes.size ()); - store->pruned_put (transaction, random_hash); + store->pruned.put (transaction, random_hash); } } - if (!nano::using_rocksdb_in_tests ()) + if (!nano::rocksdb_config::using_rocksdb_in_tests ()) { auto transaction (store->tx_begin_write ()); for (auto k (0); k < batch_size / 2; ++k) { auto hash (hashes.begin ()); - store->pruned_del (transaction, *hash); + store->pruned.del (transaction, *hash); hashes.erase (hash); } } } auto transaction (store->tx_begin_read ()); - ASSERT_EQ (expected_result, store->pruned_count (transaction)); + ASSERT_EQ (expected_result, store->pruned.count (transaction)); } // Reinitialize store { - auto store = nano::make_store (logger, path); + auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_FALSE (store->init_error ()); auto transaction (store->tx_begin_read ()); - ASSERT_EQ (expected_result, store->pruned_count (transaction)); + ASSERT_EQ (expected_result, store->pruned.count (transaction)); } } @@ -482,13 +489,13 @@ TEST (wallets, rep_scan) TEST (node, mass_vote_by_hash) { nano::system system (1); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - nano::block_hash previous (nano::genesis_hash); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + nano::block_hash previous (nano::dev::genesis->hash ()); nano::keypair key; std::vector> blocks; for (auto i (0); i < 10000; ++i) { - auto block (std::make_shared (nano::dev_genesis_key.pub, previous, nano::dev_genesis_key.pub, nano::genesis_amount - (i + 1) * nano::MBAN_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (previous))); + auto block (std::make_shared (nano::dev::genesis_key.pub, previous, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - (i + 1) * nano::MBAN_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous))); previous = block->hash (); blocks.push_back (block); } @@ -507,13 +514,13 @@ TEST (confirmation_height, many_accounts_single_confirmation) node_config.online_weight_minimum = 100; node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); // The number of frontiers should be more than the nano::confirmation_height::unbounded_cutoff to test the amount of blocks confirmed is correct. node->confirmation_height_processor.batch_write_size = 500; auto const num_accounts = nano::confirmation_height::unbounded_cutoff * 2 + 50; - nano::keypair last_keypair = nano::dev_genesis_key; - auto last_open_hash = node->latest (nano::dev_genesis_key.pub); + nano::keypair last_keypair = nano::dev::genesis_key; + auto last_open_hash = node->latest (nano::dev::genesis_key.pub); { auto transaction = node->store.tx_begin_write (); for (auto i = num_accounts - 1; i > 0; --i) @@ -544,19 +551,19 @@ TEST (confirmation_height, many_accounts_single_confirmation) // All frontiers (except last) should have 2 blocks and both should be confirmed auto transaction = node->store.tx_begin_read (); - for (auto i (node->store.accounts_begin (transaction)), n (node->store.accounts_end ()); i != n; ++i) + for (auto i (node->store.account.begin (transaction)), n (node->store.account.end ()); i != n; ++i) { auto & account = i->first; auto & account_info = i->second; auto count = (account != last_keypair.pub) ? 2 : 1; nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (node->store.confirmation_height_get (transaction, account, confirmation_height_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, account, confirmation_height_info)); ASSERT_EQ (count, confirmation_height_info.height); ASSERT_EQ (count, account_info.block_count); } size_t cemented_count = 0; - for (auto i (node->ledger.store.confirmation_height_begin (transaction)), n (node->ledger.store.confirmation_height_end ()); i != n; ++i) + for (auto i (node->ledger.store.confirmation_height.begin (transaction)), n (node->ledger.store.confirmation_height.end ()); i != n; ++i) { cemented_count += i->second.height; } @@ -577,11 +584,11 @@ TEST (confirmation_height, many_accounts_many_confirmations) node_config.online_weight_minimum = 100; node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); node->confirmation_height_processor.batch_write_size = 500; auto const num_accounts = nano::confirmation_height::unbounded_cutoff * 2 + 50; - auto latest_genesis = node->latest (nano::dev_genesis_key.pub); + auto latest_genesis = node->latest (nano::dev::genesis_key.pub); std::vector> open_blocks; { auto transaction = node->store.tx_begin_write (); @@ -590,9 +597,9 @@ TEST (confirmation_height, many_accounts_many_confirmations) nano::keypair key; system.wallet (0)->insert_adhoc (key.prv); - nano::send_block send (latest_genesis, key.pub, node->online_reps.delta (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest_genesis)); + nano::send_block send (latest_genesis, key.pub, node->online_reps.delta (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis)); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); - auto open = std::make_shared (send.hash (), nano::dev_genesis_key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); + auto open = std::make_shared (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); open_blocks.push_back (std::move (open)); latest_genesis = send.hash (); @@ -619,7 +626,7 @@ TEST (confirmation_height, many_accounts_many_confirmations) auto transaction = node->store.tx_begin_read (); size_t cemented_count = 0; - for (auto i (node->ledger.store.confirmation_height_begin (transaction)), n (node->ledger.store.confirmation_height_end ()); i != n; ++i) + for (auto i (node->ledger.store.confirmation_height.begin (transaction)), n (node->ledger.store.confirmation_height.end ()); i != n; ++i) { cemented_count += i->second.height; } @@ -639,16 +646,16 @@ TEST (confirmation_height, long_chains) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config); nano::keypair key1; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); - nano::block_hash latest (node->latest (nano::dev_genesis_key.pub)); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); + nano::block_hash latest (node->latest (nano::dev::genesis_key.pub)); system.wallet (0)->insert_adhoc (key1.prv); node->confirmation_height_processor.batch_write_size = 500; auto const num_blocks = nano::confirmation_height::unbounded_cutoff * 2 + 50; // First open the other account - nano::send_block send (latest, key1.pub, nano::genesis_amount - nano::MBAN_ratio + num_blocks + 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); - nano::open_block open (send.hash (), nano::genesis_account, key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); + nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio + num_blocks + 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); + nano::open_block open (send.hash (), nano::dev::genesis->account (), key1.pub, key1.prv, key1.pub, *system.work.generate (key1.pub)); { auto transaction = node->store.tx_begin_write (); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); @@ -662,7 +669,7 @@ TEST (confirmation_height, long_chains) auto transaction = node->store.tx_begin_write (); for (auto i = num_blocks - 1; i > 0; --i) { - nano::send_block send (previous_genesis_chain_hash, key1.pub, nano::genesis_amount - nano::MBAN_ratio + i + 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (previous_genesis_chain_hash)); + nano::send_block send (previous_genesis_chain_hash, key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio + i + 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous_genesis_chain_hash)); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); nano::receive_block receive (previous_destination_chain_hash, send.hash (), key1.prv, key1.pub, *system.work.generate (previous_destination_chain_hash)); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, receive).code); @@ -673,12 +680,12 @@ TEST (confirmation_height, long_chains) } // Send one from destination to genesis and pocket it - nano::send_block send1 (previous_destination_chain_hash, nano::dev_genesis_key.pub, nano::MBAN_ratio - 2, key1.prv, key1.pub, *system.work.generate (previous_destination_chain_hash)); - auto receive1 (std::make_shared (nano::dev_genesis_key.pub, previous_genesis_chain_hash, nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio + 1, send1.hash (), nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (previous_genesis_chain_hash))); + nano::send_block send1 (previous_destination_chain_hash, nano::dev::genesis_key.pub, nano::MBAN_ratio - 2, key1.prv, key1.pub, *system.work.generate (previous_destination_chain_hash)); + auto receive1 (std::make_shared (nano::dev::genesis_key.pub, previous_genesis_chain_hash, nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio + 1, send1.hash (), nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (previous_genesis_chain_hash))); // Unpocketed. Send to a non-existing account to prevent auto receives from the wallet adjusting expected confirmation height nano::keypair key2; - nano::state_block send2 (nano::genesis_account, receive1->hash (), nano::genesis_account, nano::genesis_amount - nano::MBAN_ratio, key2.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (receive1->hash ())); + nano::state_block send2 (nano::dev::genesis->account (), receive1->hash (), nano::dev::genesis->account (), nano::dev::constants.genesis_amount - nano::MBAN_ratio, key2.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (receive1->hash ())); { auto transaction = node->store.tx_begin_write (); @@ -699,19 +706,19 @@ TEST (confirmation_height, long_chains) auto transaction (node->store.tx_begin_read ()); nano::account_info account_info; - ASSERT_FALSE (node->store.account_get (transaction, nano::dev_genesis_key.pub, account_info)); + ASSERT_FALSE (node->store.account.get (transaction, nano::dev::genesis_key.pub, account_info)); nano::confirmation_height_info confirmation_height_info; - ASSERT_FALSE (node->store.confirmation_height_get (transaction, nano::dev_genesis_key.pub, confirmation_height_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, nano::dev::genesis_key.pub, confirmation_height_info)); ASSERT_EQ (num_blocks + 2, confirmation_height_info.height); ASSERT_EQ (num_blocks + 3, account_info.block_count); // Includes the unpocketed send - ASSERT_FALSE (node->store.account_get (transaction, key1.pub, account_info)); - ASSERT_FALSE (node->store.confirmation_height_get (transaction, key1.pub, confirmation_height_info)); + ASSERT_FALSE (node->store.account.get (transaction, key1.pub, account_info)); + ASSERT_FALSE (node->store.confirmation_height.get (transaction, key1.pub, confirmation_height_info)); ASSERT_EQ (num_blocks + 1, confirmation_height_info.height); ASSERT_EQ (num_blocks + 1, account_info.block_count); size_t cemented_count = 0; - for (auto i (node->ledger.store.confirmation_height_begin (transaction)), n (node->ledger.store.confirmation_height_end ()); i != n; ++i) + for (auto i (node->ledger.store.confirmation_height.begin (transaction)), n (node->ledger.store.confirmation_height.end ()); i != n; ++i) { cemented_count += i->second.height; } @@ -732,13 +739,13 @@ TEST (confirmation_height, dynamic_algorithm) node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config); nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto const num_blocks = nano::confirmation_height::unbounded_cutoff; - auto latest_genesis = nano::genesis ().open; + auto latest_genesis = nano::dev::genesis; std::vector> state_blocks; for (auto i = 0; i < num_blocks; ++i) { - auto send (std::make_shared (nano::dev_genesis_key.pub, latest_genesis->hash (), nano::dev_genesis_key.pub, nano::genesis_amount - i - 1, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest_genesis->hash ()))); + auto send (std::make_shared (nano::dev::genesis_key.pub, latest_genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - i - 1, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis->hash ()))); latest_genesis = send; state_blocks.push_back (send); } @@ -786,15 +793,15 @@ TEST (confirmation_height, dynamic_algorithm_no_transition_while_pending) node_flags.force_use_write_database_queue = true; auto node = system.add_node (node_config, node_flags); nano::keypair key; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); - auto latest_genesis = node->latest (nano::dev_genesis_key.pub); + auto latest_genesis = node->latest (nano::dev::genesis_key.pub); std::vector> state_blocks; auto const num_blocks = nano::confirmation_height::unbounded_cutoff - 2; auto add_block_to_genesis_chain = [&] (nano::write_transaction & transaction) { static int num = 0; - auto send (std::make_shared (nano::dev_genesis_key.pub, latest_genesis, nano::dev_genesis_key.pub, nano::genesis_amount - num - 1, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest_genesis))); + auto send (std::make_shared (nano::dev::genesis_key.pub, latest_genesis, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - num - 1, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis))); latest_genesis = send->hash (); state_blocks.push_back (send); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *send).code); @@ -855,7 +862,7 @@ TEST (confirmation_height, many_accounts_send_receive_self) nano::node_flags node_flags; node_flags.confirmation_height_processor_mode = nano::confirmation_height_mode::unbounded; auto node = system.add_node (node_config); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); #ifndef NDEBUG auto const num_accounts = 10000; @@ -863,7 +870,7 @@ TEST (confirmation_height, many_accounts_send_receive_self) auto const num_accounts = 100000; #endif - auto latest_genesis = node->latest (nano::dev_genesis_key.pub); + auto latest_genesis = node->latest (nano::dev::genesis_key.pub); std::vector keys; std::vector> open_blocks; { @@ -873,9 +880,9 @@ TEST (confirmation_height, many_accounts_send_receive_self) nano::keypair key; keys.emplace_back (key); - nano::send_block send (latest_genesis, key.pub, nano::genesis_amount - 1 - i, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest_genesis)); + nano::send_block send (latest_genesis, key.pub, nano::dev::constants.genesis_amount - 1 - i, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis)); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); - auto open = std::make_shared (send.hash (), nano::dev_genesis_key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); + auto open = std::make_shared (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, *open).code); open_blocks.push_back (std::move (open)); latest_genesis = send.hash (); @@ -931,7 +938,7 @@ TEST (confirmation_height, many_accounts_send_receive_self) auto transaction = node->store.tx_begin_read (); size_t cemented_count = 0; - for (auto i (node->ledger.store.confirmation_height_begin (transaction)), n (node->ledger.store.confirmation_height_end ()); i != n; ++i) + for (auto i (node->ledger.store.confirmation_height.begin (transaction)), n (node->ledger.store.confirmation_height.end ()); i != n; ++i) { cemented_count += i->second.height; } @@ -956,7 +963,7 @@ TEST (confirmation_height, many_accounts_send_receive_self) // as opposed to active transactions which implicitly calls confirmation height processor. TEST (confirmation_height, many_accounts_send_receive_self_no_elections) { - if (nano::using_rocksdb_in_tests ()) + if (nano::rocksdb_config::using_rocksdb_in_tests ()) { // Don't test this in rocksdb mode return; @@ -964,13 +971,12 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) nano::logger_mt logger; nano::logging logging; auto path (nano::unique_path ()); - auto store = nano::make_store (logger, path); + auto store = nano::make_store (logger, path, nano::dev::constants); ASSERT_TRUE (!store->init_error ()); - nano::genesis genesis; nano::stat stats; - nano::ledger ledger (*store, stats); + nano::ledger ledger (*store, stats, nano::dev::constants); nano::write_database_queue write_database_queue (false); - nano::work_pool pool (std::numeric_limits::max ()); + nano::work_pool pool{ nano::dev::network_params.network, std::numeric_limits::max () }; std::atomic stopped{ false }; boost::latch initialized_latch{ 0 }; @@ -979,7 +985,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) auto const num_accounts = 100000; - auto latest_genesis = nano::genesis_hash; + auto latest_genesis = nano::dev::genesis->hash (); std::vector keys; std::vector> open_blocks; @@ -987,16 +993,16 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) { auto transaction (store->tx_begin_write ()); - store->initialize (transaction, genesis, ledger.cache); + store->initialize (transaction, ledger.cache); // Send from genesis account to all other accounts and create open block for them for (auto i = 0; i < num_accounts; ++i) { nano::keypair key; keys.emplace_back (key); - nano::send_block send (latest_genesis, key.pub, nano::genesis_amount - 1 - i, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *pool.generate (latest_genesis)); + nano::send_block send (latest_genesis, key.pub, nano::dev::constants.genesis_amount - 1 - i, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *pool.generate (latest_genesis)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, send).code); - auto open = std::make_shared (send.hash (), nano::dev_genesis_key.pub, key.pub, key.prv, key.pub, *pool.generate (key.pub)); + auto open = std::make_shared (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *pool.generate (key.pub)); ASSERT_EQ (nano::process_result::progress, ledger.process (transaction, *open).code); open_blocks.push_back (std::move (open)); latest_genesis = send.hash (); @@ -1061,7 +1067,7 @@ TEST (confirmation_height, many_accounts_send_receive_self_no_elections) auto transaction = store->tx_begin_read (); size_t cemented_count = 0; - for (auto i (store->confirmation_height_begin (transaction)), n (store->confirmation_height_end ()); i != n; ++i) + for (auto i (store->confirmation_height.begin (transaction)), n (store->confirmation_height.end ()); i != n; ++i) { cemented_count += i->second.height; } @@ -1077,15 +1083,15 @@ TEST (confirmation_height, prioritize_frontiers_overwrite) nano::node_config node_config (nano::get_available_port (), system.logging); node_config.frontiers_confirmation = nano::frontiers_confirmation_mode::disabled; auto node = system.add_node (node_config); - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); auto num_accounts = node->active.max_priority_cementable_frontiers * 2; - nano::keypair last_keypair = nano::dev_genesis_key; - auto last_open_hash = node->latest (nano::dev_genesis_key.pub); + nano::keypair last_keypair = nano::dev::genesis_key; + auto last_open_hash = node->latest (nano::dev::genesis_key.pub); // Clear confirmation height so that the genesis account has the same amount of uncemented blocks as the other frontiers { auto transaction = node->store.tx_begin_write (); - node->store.confirmation_height_clear (transaction); + node->store.confirmation_height.clear (transaction); } { @@ -1119,9 +1125,9 @@ TEST (confirmation_height, prioritize_frontiers_overwrite) // Add a new frontier with 1 block, it should not be added to the frontier container because it is not higher than any already in the maxed out container nano::keypair key; - auto latest_genesis = node->latest (nano::dev_genesis_key.pub); - nano::send_block send (latest_genesis, key.pub, nano::MBAN_ratio - 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest_genesis)); - nano::open_block open (send.hash (), nano::dev_genesis_key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); + auto latest_genesis = node->latest (nano::dev::genesis_key.pub); + nano::send_block send (latest_genesis, key.pub, nano::MBAN_ratio - 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis)); + nano::open_block open (send.hash (), nano::dev::genesis_key.pub, key.pub, key.prv, key.pub, *system.work.generate (key.pub)); { auto transaction = node->store.tx_begin_write (); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); @@ -1133,7 +1139,7 @@ TEST (confirmation_height, prioritize_frontiers_overwrite) ASSERT_EQ (node->active.priority_wallet_cementable_frontiers_size (), num_accounts / 2); // The account now has an extra block (2 in total) so has 1 more uncemented block than the next smallest frontier in the collection. - nano::send_block send1 (send.hash (), key.pub, nano::MBAN_ratio - 2, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (send.hash ())); + nano::send_block send1 (send.hash (), key.pub, nano::MBAN_ratio - 2, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (send.hash ())); nano::receive_block receive (open.hash (), send1.hash (), key.prv, key.pub, *system.work.generate (open.hash ())); { auto transaction = node->store.tx_begin_write (); @@ -1234,7 +1240,7 @@ namespace transport nano::system system; nano::node_flags node_flags; node_flags.disable_initial_telemetry_requests = true; - const auto num_nodes = 4; + auto const num_nodes = 4; for (int i = 0; i < num_nodes; ++i) { system.add_node (node_flags); @@ -1243,7 +1249,7 @@ namespace transport wait_peer_connections (system); std::vector threads; - const auto num_threads = 4; + auto const num_threads = 4; std::array node_data{}; for (auto i = 0; i < num_nodes; ++i) @@ -1305,14 +1311,13 @@ TEST (telemetry, under_load) auto node = system.add_node (node_config, node_flags); node_config.peering_port = nano::get_available_port (); auto node1 = system.add_node (node_config, node_flags); - nano::genesis genesis; nano::keypair key; nano::keypair key1; - system.wallet (0)->insert_adhoc (nano::dev_genesis_key.prv); + system.wallet (0)->insert_adhoc (nano::dev::genesis_key.prv); system.wallet (0)->insert_adhoc (key.prv); - auto latest_genesis = node->latest (nano::dev_genesis_key.pub); + auto latest_genesis = node->latest (nano::dev::genesis_key.pub); auto num_blocks = 150000; - auto send (std::make_shared (nano::dev_genesis_key.pub, latest_genesis, nano::dev_genesis_key.pub, nano::genesis_amount - num_blocks, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest_genesis))); + auto send (std::make_shared (nano::dev::genesis_key.pub, latest_genesis, nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - num_blocks, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest_genesis))); node->process_active (send); latest_genesis = send->hash (); auto open (std::make_shared (key.pub, 0, key.pub, num_blocks, send->hash (), key.prv, key.pub, *system.work.generate (key.pub))); @@ -1329,7 +1334,7 @@ TEST (telemetry, under_load) } }; - std::thread thread1 (thread_func, nano::dev_genesis_key, latest_genesis, nano::genesis_amount - num_blocks); + std::thread thread1 (thread_func, nano::dev::genesis_key, latest_genesis, nano::dev::constants.genesis_amount - num_blocks); std::thread thread2 (thread_func, key, latest_key, num_blocks); ASSERT_TIMELY (200s, node1->ledger.cache.block_count == num_blocks * 2 + 3); @@ -1417,7 +1422,7 @@ TEST (telemetry, many_nodes) node_flags.disable_initial_telemetry_requests = true; node_flags.disable_request_loop = true; // The telemetry responses can timeout if using a large number of nodes under sanitizers, so lower the number. - const auto num_nodes = (is_sanitizer_build || nano::running_within_valgrind ()) ? 4 : 10; + auto const num_nodes = (is_sanitizer_build || nano::running_within_valgrind ()) ? 4 : 10; for (auto i = 0; i < num_nodes; ++i) { nano::node_config node_config (nano::get_available_port (), system.logging); @@ -1446,8 +1451,7 @@ TEST (telemetry, many_nodes) // Give all nodes a non-default number of blocks nano::keypair key; - nano::genesis genesis; - nano::state_block send (nano::dev_genesis_key.pub, genesis.hash (), nano::dev_genesis_key.pub, nano::genesis_amount - nano::BAN_ratio, key.pub, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (genesis.hash ())); + nano::state_block send (nano::dev::genesis_key.pub, nano::dev::genesis->hash (), nano::dev::genesis_key.pub, nano::dev::constants.genesis_amount - nano::BAN_ratio, key.pub, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (nano::dev::genesis->hash ())); for (auto node : system.nodes) { auto transaction (node->store.tx_begin_write ()); @@ -1480,7 +1484,6 @@ TEST (telemetry, many_nodes) } // Check the metrics - nano::network_params params; for (auto & data : telemetry_datas) { ASSERT_EQ (data.unchecked_count, 0); @@ -1488,7 +1491,7 @@ TEST (telemetry, many_nodes) ASSERT_LE (data.peer_count, 9U); ASSERT_EQ (data.account_count, 1); ASSERT_TRUE (data.block_count == 2); - ASSERT_EQ (data.protocol_version, params.protocol.protocol_version); + ASSERT_EQ (data.protocol_version, nano::dev::network_params.network.protocol_version); ASSERT_GE (data.bandwidth_cap, 100000); ASSERT_LT (data.bandwidth_cap, 100000 + system.nodes.size ()); ASSERT_EQ (data.major_version, nano::get_major_node_version ()); @@ -1497,7 +1500,7 @@ TEST (telemetry, many_nodes) ASSERT_EQ (data.pre_release_version, nano::get_pre_release_node_version ()); ASSERT_EQ (data.maker, 0); ASSERT_LT (data.uptime, 100); - ASSERT_EQ (data.genesis_block, genesis.hash ()); + ASSERT_EQ (data.genesis_block, nano::dev::genesis->hash ()); ASSERT_LE (data.timestamp, std::chrono::system_clock::now ()); ASSERT_EQ (data.active_difficulty, system.nodes.front ()->default_difficulty (nano::work_version::work_1)); } @@ -1594,8 +1597,8 @@ TEST (node, mass_epoch_upgrader) //node_config.work_peers = { { "192.168.1.101", 7000 } }; auto & node = *system.add_node (node_config); - auto balance = node.balance (nano::dev_genesis_key.pub); - auto latest = node.latest (nano::dev_genesis_key.pub); + auto balance = node.balance (nano::dev::genesis_key.pub); + auto latest = node.latest (nano::dev::genesis_key.pub); nano::uint128_t amount = 1; // Send to all accounts @@ -1608,13 +1611,13 @@ TEST (node, mass_epoch_upgrader) nano::state_block_builder builder; std::error_code ec; auto block = builder - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (latest) .balance (balance) .link (info.key.pub) - .representative (nano::dev_genesis_key.pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) - .work (*node.work_generate_blocking (latest, nano::work_threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_0, false, false, false)))) + .representative (nano::dev::genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*node.work_generate_blocking (latest, node_config.network_params.work.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_0, false, false, false)))) .build (ec); ASSERT_FALSE (ec); ASSERT_NE (nullptr, block); @@ -1638,7 +1641,7 @@ TEST (node, mass_epoch_upgrader) .link (info.pending_hash) .representative (info.key.pub) .sign (info.key.prv, info.key.pub) - .work (*node.work_generate_blocking (info.key.pub, nano::work_threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_0, false, false, false)))) + .work (*node.work_generate_blocking (info.key.pub, node_config.network_params.work.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_0, false, false, false)))) .build (ec); ASSERT_FALSE (ec); ASSERT_NE (nullptr, block); @@ -1647,7 +1650,7 @@ TEST (node, mass_epoch_upgrader) ASSERT_EQ (1 + total_accounts + opened.size (), node.ledger.cache.block_count); ASSERT_EQ (1 + opened.size (), node.ledger.cache.account_count); - nano::keypair epoch_signer (nano::dev_genesis_key); + nano::keypair epoch_signer (nano::dev::genesis_key); auto const block_count_before = node.ledger.cache.block_count.load (); auto const total_to_upgrade = 1 + total_accounts; @@ -1674,7 +1677,7 @@ TEST (node, mass_epoch_upgrader) { auto transaction (node.store.tx_begin_read ()); size_t block_count_sum = 0; - for (auto i (node.store.accounts_begin (transaction)); i != node.store.accounts_end (); ++i) + for (auto i (node.store.account.begin (transaction)); i != node.store.account.end (); ++i) { nano::account_info info (i->second); ASSERT_EQ (info.epoch (), nano::epoch::epoch_1); @@ -1724,22 +1727,21 @@ TEST (node, mass_block_new) } }; - nano::genesis genesis; nano::keypair key; std::vector keys (num_blocks); nano::state_block_builder builder; std::vector> send_blocks; - auto send_threshold (nano::work_threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, true, false, false))); - auto latest_genesis = node.latest (nano::dev_genesis_key.pub); + auto send_threshold (nano::dev::network_params.work.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, true, false, false))); + auto latest_genesis = node.latest (nano::dev::genesis_key.pub); for (auto i = 0; i < num_blocks; ++i) { auto send = builder.make_block () - .account (nano::dev_genesis_key.pub) + .account (nano::dev::genesis_key.pub) .previous (latest_genesis) - .balance (nano::genesis_amount - i - 1) - .representative (nano::dev_genesis_key.pub) + .balance (nano::dev::constants.genesis_amount - i - 1) + .representative (nano::dev::genesis_key.pub) .link (keys[i].pub) - .sign (nano::dev_genesis_key.prv, nano::dev_genesis_key.pub) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) .work (*system.work.generate (nano::work_version::work_1, latest_genesis, send_threshold)) .build (); latest_genesis = send->hash (); @@ -1752,7 +1754,7 @@ TEST (node, mass_block_new) std::cout << "Send blocks time: " << timer.stop ().count () << " " << timer.unit () << "\n\n"; std::vector> open_blocks; - auto receive_threshold (nano::work_threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, false, true, false))); + auto receive_threshold (nano::dev::network_params.work.threshold (nano::work_version::work_1, nano::block_details (nano::epoch::epoch_2, false, true, false))); for (auto i = 0; i < num_blocks; ++i) { auto const & key = keys[i]; @@ -1828,13 +1830,13 @@ TEST (node, wallet_create_block_confirm_conflicts) auto const num_blocks = 10000; // First open the other account - auto latest = nano::genesis_hash; + auto latest = nano::dev::genesis->hash (); nano::keypair key1; { auto transaction = node->store.tx_begin_write (); for (auto i = num_blocks - 1; i > 0; --i) { - nano::send_block send (latest, key1.pub, nano::genesis_amount - nano::MBAN_ratio + i + 1, nano::dev_genesis_key.prv, nano::dev_genesis_key.pub, *system.work.generate (latest)); + nano::send_block send (latest, key1.pub, nano::dev::constants.genesis_amount - nano::MBAN_ratio + i + 1, nano::dev::genesis_key.prv, nano::dev::genesis_key.pub, *system.work.generate (latest)); ASSERT_EQ (nano::process_result::progress, node->ledger.process (transaction, send).code); latest = send.hash (); } @@ -1851,7 +1853,7 @@ TEST (node, wallet_create_block_confirm_conflicts) // Call block confirm on the top level send block which will confirm everything underneath on both accounts. { - auto block = node->store.block_get (node->store.tx_begin_read (), latest); + auto block = node->store.block.get (node->store.tx_begin_read (), latest); node->scheduler.manual (block); auto election = node->active.election (block->qualified_root ()); ASSERT_NE (nullptr, election); diff --git a/nano/test_common/CMakeLists.txt b/nano/test_common/CMakeLists.txt index eef91729bc..1e70b41704 100644 --- a/nano/test_common/CMakeLists.txt +++ b/nano/test_common/CMakeLists.txt @@ -1,5 +1,13 @@ -add_library(test_common network.hpp network.cpp telemetry.hpp telemetry.cpp - testutil.hpp testutil.cpp) +add_library( + test_common + network.hpp + network.cpp + system.hpp + system.cpp + telemetry.hpp + telemetry.cpp + testutil.hpp + testutil.cpp) target_link_libraries(test_common node gtest Boost::log_setup Boost::log Boost::boost) diff --git a/nano/test_common/network.cpp b/nano/test_common/network.cpp index 5427ad6efa..1ef0faed95 100644 --- a/nano/test_common/network.cpp +++ b/nano/test_common/network.cpp @@ -1,6 +1,6 @@ #include -#include #include +#include #include #include @@ -8,36 +8,18 @@ #include #include +using namespace std::chrono_literals; + std::shared_ptr nano::establish_tcp (nano::system & system, nano::node & node, nano::endpoint const & endpoint) { - using namespace std::chrono_literals; debug_assert (node.network.endpoint () != endpoint && "Establishing TCP to self is not allowed"); std::shared_ptr result; debug_assert (!node.flags.disable_tcp_realtime); - std::promise> promise; - auto callback = [&promise] (std::shared_ptr channel_a) { promise.set_value (channel_a); }; - auto future = promise.get_future (); - node.network.tcp_channels.start_tcp (endpoint, callback); - auto error = system.poll_until_true (2s, [&future] { return future.wait_for (0s) == std::future_status::ready; }); - if (!error) - { - auto channel = future.get (); - EXPECT_NE (nullptr, channel); - if (channel) - { - result = node.network.tcp_channels.find_channel (channel->get_tcp_endpoint ()); - } - } + node.network.tcp_channels.start_tcp (endpoint); + auto error = system.poll_until_true (2s, [&result, &node, &endpoint] { + result = node.network.tcp_channels.find_channel (nano::transport::map_endpoint_to_tcp (endpoint)); + return result != nullptr; + }); return result; } - -std::function channel_a)> nano::keepalive_tcp_callback (nano::node & node_a) -{ - return [node_w = std::weak_ptr (node_a.shared ())] (std::shared_ptr channel_a) { - if (auto node_l = node_w.lock ()) - { - node_l->network.send_keepalive (channel_a); - }; - }; -} diff --git a/nano/test_common/network.hpp b/nano/test_common/network.hpp index cd68eba555..4eeea69a4b 100644 --- a/nano/test_common/network.hpp +++ b/nano/test_common/network.hpp @@ -9,12 +9,10 @@ class system; namespace transport { + class channel; class channel_tcp; } /** Waits until a TCP connection is established and returns the TCP channel on success*/ std::shared_ptr establish_tcp (nano::system &, nano::node &, nano::endpoint const &); - -/** Returns a callback to be used for start_tcp to send a keepalive*/ -std::function channel_a)> keepalive_tcp_callback (nano::node &); } diff --git a/nano/node/testing.cpp b/nano/test_common/system.cpp similarity index 86% rename from nano/node/testing.cpp rename to nano/test_common/system.cpp index c0e8341bf2..170ba9d3cc 100644 --- a/nano/node/testing.cpp +++ b/nano/test_common/system.cpp @@ -1,7 +1,8 @@ #include #include -#include #include +#include +#include #include @@ -31,6 +32,11 @@ std::shared_ptr nano::system::add_node (nano::node_flags node_flags_ std::shared_ptr nano::system::add_node (nano::node_config const & node_config_a, nano::node_flags node_flags_a, nano::transport::transport_type type_a) { auto node (std::make_shared (io_ctx, nano::unique_path (), node_config_a, work, node_flags_a, node_sequence++)); + for (auto i : initialization_blocks) + { + auto result = node->ledger.process (node->store.tx_begin_write (), *i); + debug_assert (result.code == nano::process_result::progress); + } debug_assert (!node->init_error ()); node->start (); node->wallets.create (nano::random_wallet_id ()); @@ -38,7 +44,7 @@ std::shared_ptr nano::system::add_node (nano::node_config const & no nodes.push_back (node); if (nodes.size () > 1) { - debug_assert (nodes.size () - 1 <= node->network_params.node.max_peers_per_ip || node->flags.disable_max_peers_per_ip); // Check that we don't start more nodes than limit for single IP address + debug_assert (nodes.size () - 1 <= node->network_params.network.max_peers_per_ip || node->flags.disable_max_peers_per_ip); // Check that we don't start more nodes than limit for single IP address auto begin = nodes.end () - 2; for (auto i (begin), j (begin + 1), n (nodes.end ()); j != n; ++i, ++j) { @@ -57,7 +63,7 @@ std::shared_ptr nano::system::add_node (nano::node_config const & no else { // UDP connection - auto channel (std::make_shared ((*j)->network.udp_channels, (*i)->network.endpoint (), node1->network_params.protocol.protocol_version)); + auto channel (std::make_shared ((*j)->network.udp_channels, (*i)->network.endpoint (), node1->network_params.network.protocol_version)); (*j)->network.send_keepalive (channel); } do @@ -143,6 +149,36 @@ nano::system::~system () #endif } +void nano::system::ledger_initialization_set (std::vector const & reps, nano::amount const & reserve) +{ + nano::block_hash previous = nano::dev::genesis->hash (); + auto amount = (nano::dev::constants.genesis_amount - reserve.number ()) / reps.size (); + auto balance = nano::dev::constants.genesis_amount; + for (auto const & i : reps) + { + balance -= amount; + nano::state_block_builder builder; + builder.account (nano::dev::genesis_key.pub) + .previous (previous) + .representative (nano::dev::genesis_key.pub) + .link (i.pub) + .balance (balance) + .sign (nano::dev::genesis_key.prv, nano::dev::genesis_key.pub) + .work (*work.generate (previous)); + initialization_blocks.emplace_back (builder.build_shared ()); + previous = initialization_blocks.back ()->hash (); + builder.make_block (); + builder.account (i.pub) + .previous (0) + .representative (i.pub) + .link (previous) + .balance (amount) + .sign (i.prv, i.pub) + .work (*work.generate (i.pub)); + initialization_blocks.emplace_back (builder.build_shared ()); + } +} + std::shared_ptr nano::system::wallet (size_t index_a) { debug_assert (nodes.size () > index_a); @@ -169,14 +205,14 @@ uint64_t nano::system::work_generate_limited (nano::block_hash const & root_a, u do { result = *work.generate (root_a, min_a); - } while (nano::work_difficulty (nano::work_version::work_1, root_a, result) >= max_a); + } while (work.network_constants.work.difficulty (nano::work_version::work_1, root_a, result) >= max_a); return result; } std::unique_ptr nano::upgrade_epoch (nano::work_pool & pool_a, nano::ledger & ledger_a, nano::epoch epoch_a) { auto transaction (ledger_a.store.tx_begin_write ()); - auto dev_genesis_key = nano::ledger_constants (nano::nano_networks::nano_dev_network).dev_genesis_key; + auto dev_genesis_key = nano::dev::genesis_key; auto account = dev_genesis_key.pub; auto latest = ledger_a.latest (transaction, account); auto balance = ledger_a.account_balance (transaction, account); @@ -190,7 +226,7 @@ std::unique_ptr nano::upgrade_epoch (nano::work_pool & pool_a .link (ledger_a.epoch_link (epoch_a)) .representative (dev_genesis_key.pub) .sign (dev_genesis_key.prv, dev_genesis_key.pub) - .work (*pool_a.generate (latest, nano::work_threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true)))) + .work (*pool_a.generate (latest, pool_a.network_constants.work.threshold (nano::work_version::work_1, nano::block_details (epoch_a, false, false, true)))) .build (ec); bool error{ true }; @@ -325,12 +361,11 @@ void nano::system::generate_rollback (nano::node & node_a, std::vector (accounts_a.size () - 1))); auto account (accounts_a[index]); nano::account_info info; - auto error (node_a.store.account_get (transaction, account, info)); + auto error (node_a.store.account.get (transaction, account, info)); if (!error) { auto hash (info.open_block); - nano::genesis genesis; - if (hash != genesis.hash ()) + if (hash != node_a.network_params.ledger.genesis->hash ()) { accounts_a[index] = accounts_a[accounts_a.size () - 1]; accounts_a.pop_back (); @@ -353,16 +388,16 @@ void nano::system::generate_receive (nano::node & node_a) auto transaction (node_a.store.tx_begin_read ()); nano::account random_account; random_pool::generate_block (random_account.bytes.data (), sizeof (random_account.bytes)); - auto i (node_a.store.pending_begin (transaction, nano::pending_key (random_account, 0))); - if (i != node_a.store.pending_end ()) + auto i (node_a.store.pending.begin (transaction, nano::pending_key (random_account, 0))); + if (i != node_a.store.pending.end ()) { nano::pending_key const & send_hash (i->first); - send_block = node_a.store.block_get (transaction, send_hash.hash); + send_block = node_a.store.block.get (transaction, send_hash.hash); } } if (send_block != nullptr) { - auto receive_error (wallet (0)->receive_sync (send_block, nano::ledger_constants (nano::nano_networks::nano_dev_network).genesis_account, std::numeric_limits::max ())); + auto receive_error (wallet (0)->receive_sync (send_block, nano::dev::genesis->account (), std::numeric_limits::max ())); (void)receive_error; } } @@ -421,12 +456,12 @@ void nano::system::generate_send_existing (nano::node & node_a, std::vector entry (node_a.store.accounts_begin (transaction, account)); - if (entry == node_a.store.accounts_end ()) + nano::store_iterator entry (node_a.store.account.begin (transaction, account)); + if (entry == node_a.store.account.end ()) { - entry = node_a.store.accounts_begin (transaction); + entry = node_a.store.account.begin (transaction); } - debug_assert (entry != node_a.store.accounts_end ()); + debug_assert (entry != node_a.store.account.end ()); destination = nano::account (entry->first); source = get_random_account (accounts_a); amount = get_random_amount (transaction, node_a, source); @@ -487,7 +522,7 @@ void nano::system::generate_send_new (nano::node & node_a, std::vector accounts; - auto dev_genesis_key = nano::ledger_constants (nano::nano_networks::nano_dev_network).dev_genesis_key; + auto dev_genesis_key = nano::dev::genesis_key; wallet (0)->insert_adhoc (dev_genesis_key.prv); accounts.push_back (dev_genesis_key.pub); auto previous (std::chrono::steady_clock::now ()); @@ -550,10 +585,3 @@ void nano::cleanup_dev_directories_on_exit () nano::remove_temporary_directories (); } } - -bool nano::using_rocksdb_in_tests () -{ - static nano::network_constants network_constants; - auto use_rocksdb_str = std::getenv ("TEST_USE_ROCKSDB"); - return network_constants.is_dev_network () && use_rocksdb_str && (boost::lexical_cast (use_rocksdb_str) == 1); -} diff --git a/nano/node/testing.hpp b/nano/test_common/system.hpp similarity index 86% rename from nano/node/testing.hpp rename to nano/test_common/system.hpp index aefb36e61e..93ca39f442 100644 --- a/nano/node/testing.hpp +++ b/nano/test_common/system.hpp @@ -19,6 +19,7 @@ class system final system (); system (uint16_t, nano::transport::transport_type = nano::transport::transport_type::tcp, nano::node_flags = nano::node_flags ()); ~system (); + void ledger_initialization_set (std::vector const & reps, nano::amount const & reserve = 0); void generate_activity (nano::node &, std::vector &); void generate_mass_activity (uint32_t, nano::node &); void generate_usage_traffic (uint32_t, uint32_t, size_t); @@ -40,25 +41,26 @@ class system final * Polls, sleep if there's no work to be done (default 50ms), then check the deadline * @returns 0 or nano::deadline_expired */ - std::error_code poll (const std::chrono::nanoseconds & sleep_time = std::chrono::milliseconds (50)); + std::error_code poll (std::chrono::nanoseconds const & sleep_time = std::chrono::milliseconds (50)); std::error_code poll_until_true (std::chrono::nanoseconds deadline, std::function); void stop (); - void deadline_set (const std::chrono::duration & delta); + void deadline_set (std::chrono::duration const & delta); std::shared_ptr add_node (nano::node_flags = nano::node_flags (), nano::transport::transport_type = nano::transport::transport_type::tcp); std::shared_ptr add_node (nano::node_config const &, nano::node_flags = nano::node_flags (), nano::transport::transport_type = nano::transport::transport_type::tcp); boost::asio::io_context io_ctx; std::vector> nodes; nano::logging logging; - nano::work_pool work{ std::max (std::thread::hardware_concurrency (), 1u) }; + nano::work_pool work{ nano::dev::network_params.network, std::max (std::thread::hardware_concurrency (), 1u) }; std::chrono::time_point> deadline{ std::chrono::steady_clock::time_point::max () }; double deadline_scaling_factor{ 1.0 }; unsigned node_sequence{ 0 }; + +private: + std::vector> initialization_blocks; }; std::unique_ptr upgrade_epoch (nano::work_pool &, nano::ledger &, nano::epoch); void blocks_confirm (nano::node &, std::vector> const &, bool const = false); uint16_t get_available_port (); void cleanup_dev_directories_on_exit (); -/** To use RocksDB in tests make sure the environment variable TEST_USE_ROCKSDB=1 is set */ -bool using_rocksdb_in_tests (); } REGISTER_ERROR_CODES (nano, error_system); diff --git a/nano/test_common/telemetry.cpp b/nano/test_common/telemetry.cpp index 7485ca618d..702bbdc466 100644 --- a/nano/test_common/telemetry.cpp +++ b/nano/test_common/telemetry.cpp @@ -9,11 +9,11 @@ void nano::compare_default_telemetry_response_data_excluding_signature (nano::te ASSERT_EQ (telemetry_data_a.cemented_count, 1); ASSERT_EQ (telemetry_data_a.bandwidth_cap, bandwidth_limit_a); ASSERT_EQ (telemetry_data_a.peer_count, 1); - ASSERT_EQ (telemetry_data_a.protocol_version, network_params_a.protocol.protocol_version); + ASSERT_EQ (telemetry_data_a.protocol_version, network_params_a.network.protocol_version); ASSERT_EQ (telemetry_data_a.unchecked_count, 0); ASSERT_EQ (telemetry_data_a.account_count, 1); ASSERT_LT (telemetry_data_a.uptime, 100); - ASSERT_EQ (telemetry_data_a.genesis_block, network_params_a.ledger.genesis_hash); + ASSERT_EQ (telemetry_data_a.genesis_block, network_params_a.ledger.genesis->hash ()); ASSERT_EQ (telemetry_data_a.major_version, nano::get_major_node_version ()); ASSERT_EQ (telemetry_data_a.minor_version, nano::get_minor_node_version ()); ASSERT_EQ (telemetry_data_a.patch_version, nano::get_patch_node_version ()); diff --git a/nano/test_common/testutil.cpp b/nano/test_common/testutil.cpp index e1298b1dd0..a0ef80634a 100644 --- a/nano/test_common/testutil.cpp +++ b/nano/test_common/testutil.cpp @@ -1,5 +1,5 @@ #include -#include +#include #include #include @@ -9,21 +9,6 @@ using namespace std::chrono_literals; -/* Convenience constants for tests which are always on the test network */ -namespace -{ -nano::ledger_constants dev_constants (nano::nano_networks::nano_dev_network); -} - -nano::keypair const & nano::zero_key (dev_constants.zero_key); -nano::keypair const & nano::dev_genesis_key (dev_constants.dev_genesis_key); -nano::account const & nano::nano_dev_account (dev_constants.nano_dev_account); -std::string const & nano::nano_dev_genesis (dev_constants.nano_dev_genesis); -nano::account const & nano::genesis_account (dev_constants.genesis_account); -nano::block_hash const & nano::genesis_hash (dev_constants.genesis_hash); -nano::uint128_t const & nano::genesis_amount (dev_constants.genesis_amount); -nano::account const & nano::burn_account (dev_constants.burn_account); - void nano::wait_peer_connections (nano::system & system_a) { auto wait_peer_count = [&system_a] (bool in_memory) { @@ -41,7 +26,7 @@ void nano::wait_peer_connections (nano::system & system_a) else { auto transaction = node->store.tx_begin_read (); - return total += node->store.peer_count (transaction); + return total += node->store.peer.count (transaction); } }); } diff --git a/nano/test_common/testutil.hpp b/nano/test_common/testutil.hpp index 374c4c10b9..1c9147dcb0 100644 --- a/nano/test_common/testutil.hpp +++ b/nano/test_common/testutil.hpp @@ -53,14 +53,6 @@ class telemetry_data; class network_params; class system; -extern nano::keypair const & zero_key; -extern nano::keypair const & dev_genesis_key; -extern std::string const & nano_dev_genesis; -extern std::string const & genesis_block; -extern nano::block_hash const & genesis_hash; -extern nano::public_key const & nano_dev_account; -extern nano::public_key const & genesis_account; -extern nano::public_key const & burn_account; extern nano::uint128_t const & genesis_amount; class stringstream_mt_sink : public boost::iostreams::sink @@ -73,7 +65,7 @@ class stringstream_mt_sink : public boost::iostreams::sink ss << sink.ss.str (); } - std::streamsize write (const char * string_to_write, std::streamsize size) + std::streamsize write (char const * string_to_write, std::streamsize size) { nano::lock_guard guard (mutex); ss << std::string (string_to_write, size); diff --git a/rep_weights_live.bin b/rep_weights_live.bin index daa476bfb7..1cb4e9e299 100644 Binary files a/rep_weights_live.bin and b/rep_weights_live.bin differ diff --git a/systest/.gitignore b/systest/.gitignore new file mode 100644 index 0000000000..72d072bebc --- /dev/null +++ b/systest/.gitignore @@ -0,0 +1 @@ +/data.systest diff --git a/systest/RUNALL b/systest/RUNALL new file mode 100755 index 0000000000..873785be06 --- /dev/null +++ b/systest/RUNALL @@ -0,0 +1,12 @@ +#!/bin/sh + +set -e + +failed=0 + +for script in *.sh; do + echo Running script: $script + ./$script; +done + +echo All systests passed. diff --git a/systest/cli_wallet_create.sh b/systest/cli_wallet_create.sh new file mode 100755 index 0000000000..d2ac7b35d4 --- /dev/null +++ b/systest/cli_wallet_create.sh @@ -0,0 +1,38 @@ +#!/bin/sh + +set -e + +DATADIR=data.systest + +SEED=CEEDCEEDCEEDCEEDCEEDCEEDCEEDCEEDCEEDCEEDCEEDCEEDCEEDCEEDCEEDCEED + +# the caller should set the env var NANO_NODE_EXE to point to the nano_node executable +# if NANO_NODE_EXE is unser ot empty then "../../build/nano_node" is used +NANO_NODE_EXE=${NANO_NODE_EXE:-../../build/nano_node} + +clean_data_dir() { + rm -f $DATADIR/log/log_*.log + rm -f $DATADIR/wallets.ldb* + rm -f $DATADIR/data.ldb* + rm -f $DATADIR/config-*.toml + rm -rf "$DATADIR"/rocksdb/ +} + +mkdir -p $DATADIR/log +clean_data_dir + +# initialise data directory +$NANO_NODE_EXE --initialize --data_path $DATADIR + +# create a wallet and store the wallet ID +wallet_id=`$NANO_NODE_EXE --wallet_create --data_path $DATADIR --seed $SEED` + +# decrypt the wallet and check the seed +$NANO_NODE_EXE --wallet_decrypt_unsafe --wallet $wallet_id --data_path $DATADIR | grep -q "Seed: $SEED" + +# list the wallet and check the wallet ID +$NANO_NODE_EXE --wallet_list --data_path $DATADIR | grep -q "Wallet ID: $wallet_id" + +# if it got this far then it is a pass +echo $0: PASSED +exit 0 diff --git a/systest/node_initialize.sh b/systest/node_initialize.sh new file mode 100755 index 0000000000..bf434f27c3 --- /dev/null +++ b/systest/node_initialize.sh @@ -0,0 +1,49 @@ +#!/bin/sh + +set -e + +DATADIR=data.systest + +# the caller should set the env var NANO_NODE_EXE to point to the nano_node executable +# if NANO_NODE_EXE is unser ot empty then "../../build/nano_node" is used +NANO_NODE_EXE=${NANO_NODE_EXE:-../../build/nano_node} + +clean_data_dir() { + rm -f "$DATADIR"/log/log_*.log + rm -f "$DATADIR"/wallets.ldb* + rm -f "$DATADIR"/data.ldb* + rm -f "$DATADIR"/config-*.toml + rm -rf "$DATADIR"/rocksdb/ +} + +test_initialize_cmd() { + netmatch="$1" + netcmd="$2" + netarg="$3" + genesishash="$4" + + clean_data_dir + + # initialise data directory + $NANO_NODE_EXE --initialize --data_path "$DATADIR" "$netcmd" "$netarg" + + # check that it is the live network + grep -q "Active network: $netmatch" "$DATADIR"/log/log_*.log + + # check that the ledger file is created and has one block, the genesis block + $NANO_NODE_EXE --debug_block_count --data_path "$DATADIR" "$netcmd" "$netarg" | grep -q 'Block count: 1' + + # check the genesis block is correct + $NANO_NODE_EXE --debug_block_dump --data_path "$DATADIR" "$netcmd" "$netarg" | head -n 1 | grep -qi "$genesishash" +} + +mkdir -p "$DATADIR/log" + +#test_initialize_cmd "live" "" "" "991CF190094C00F0B68E2E5F75F6BEE95A2E0BD93CEAA4A6734DB9F19B728948" +test_initialize_cmd "live" "--network" "live" "991CF190094C00F0B68E2E5F75F6BEE95A2E0BD93CEAA4A6734DB9F19B728948" +test_initialize_cmd "beta" "--network" "beta" "01A92459E69440D5C1088D3B31F4CA678BE944BAB3776C2E6B7665E9BD99BD5A" +test_initialize_cmd "test" "--network" "test" "B1D60C0B886B57401EF5A1DAA04340E53726AA6F4D706C085706F31BBD100CEE" + +# if it got this far then it is a pass +echo $0: PASSED +exit 0 diff --git a/systest/set_bandwidth_params.sh b/systest/set_bandwidth_params.sh index 4c02291a3d..2b63088938 100755 --- a/systest/set_bandwidth_params.sh +++ b/systest/set_bandwidth_params.sh @@ -1,24 +1,41 @@ #!/bin/sh +set -e + +DATADIR=data.systest + +clean_data_dir() { + rm -f "$DATADIR"/log/log_*.log + rm -f "$DATADIR"/wallets.ldb* + rm -f "$DATADIR"/data.ldb* + rm -f "$DATADIR"/config-*.toml + rm -rf "$DATADIR"/rocksdb/ +} + +msg() { + : + #echo "$@" +} + # the caller should set the env var NANO_NODE_EXE to point to the nano_node executable -# if NANO_NODE_EXE is unser ot empty then "../../build/nano_node" is used +# if NANO_NODE_EXE is unset ot empty then "../../build/nano_node" is used NANO_NODE_EXE=${NANO_NODE_EXE:-../../build/nano_node} -mkdir -p data/log -rm data/log/log_*.log +mkdir -p "$DATADIR/log" +clean_data_dir # start nano_node and store its pid so we can later send it # the SIGHUP signal and so we can terminate it -echo start nano_node -$NANO_NODE_EXE --daemon --data_path data & +msg start nano_node +$NANO_NODE_EXE --daemon --data_path "$DATADIR" >/dev/null & pid=$! -echo pid=$pid +msg pid=$pid # wait for the node to start-up sleep 2 # set bandwidth params 42 and 43 in the config file -cat > data/config-node.toml < "$DATADIR/config-node.toml" < data/config-node.toml < "$DATADIR/config-node.toml" <